Python · Lección 05 de 27

Operaciones básicas

Aritméticas, de comparación, lógicas y de asignación — los cuatro pilares del cálculo en Python. Toda fórmula, toda decisión y todo filtro que construyas parte de acá.

80–100 min Prerrequisitos: 03 Tipos de datos, 04 Variables

Concepto teórico

Los operadores son símbolos que le dicen a Python qué hacer con los datos. Sin operadores, un programa no puede calcular nada: no puede sumar un saldo, comparar dos scores, ni decidir si un cliente califica para un crédito. Hay cuatro familias que necesitás dominar y que vamos a cubrir en profundidad.

Operadores aritméticos

Son los más intuitivos porque son las operaciones matemáticas que ya conocés. Pero Python agrega tres que probablemente no hayas visto:

Operador	Nombre	Ejemplo	Resultado	¿Para qué sirve?
`+`	Suma	`15 + 4`	`19`	Sumar montos, acumular totales
`-`	Resta	`15 - 4`	`11`	Calcular diferencias, margen
`*`	Multiplicación	`15 * 4`	`60`	Precio × cantidad, tasa × capital
`/`	División	`15 / 4`	`3.75`	Promedios, ratios. Siempre devuelve float
`//`	División entera	`15 // 4`	`3`	Cuotas enteras, lotes completos
`%`	Módulo (resto)	`15 % 4`	`3`	¿Es par? ¿Es múltiplo? Distribuir sobrantes
`**`	Potencia	`2 ** 10`	`1024`	Interés compuesto: capital × (1+tasa)**n

Punto clave: la división (/) siempre devuelve float. Incluso 10 / 2 devuelve 5.0, no 5. Si necesitás un entero, usá // (división entera) o int(). Esto importa cuando construís IDs, índices o contadores que deben ser enteros.

El operador % (módulo) merece atención especial. Devuelve el resto de una división. Sus usos más comunes en análisis de datos:

Verificar paridad: n % 2 == 0 → el número es par
Verificar múltiplos: n % 12 == 0 → el número es múltiplo de 12 (útil para meses)
Distribuir sobrantes: si tenés $17,000 para repartir entre 5 personas, cada uno recibe 17000 // 5 = $3,400 y sobran 17000 % 5 = $0
Ciclos: i % 3 genera la secuencia 0, 1, 2, 0, 1, 2... ideal para alternar colores o categorías

El operador ** (potencia) es tu herramienta para interés compuesto. La fórmula financiera más importante que vas a usar es:

monto_final = capital * (1 + tasa) ** periodos

Por ejemplo, $100,000 al 5% mensual durante 12 meses: 100000 * (1.05) ** 12 = $179,585.63. Esa sola línea reemplaza una planilla entera de Excel.

Error común: confundir / con //. Si calculás 7 / 2 esperando 3, vas a obtener 3.5. Si calculás 7 // 2 esperando 3.5, vas a obtener 3. Siempre pensá cuál necesitás antes de escribir la línea.

Precedencia de operadores (orden de evaluación)

Así como en matemática primero va la multiplicación y después la suma, Python sigue un orden estricto:

** (potencia) — se evalúa primero
*, /, //, % — segundo
+, - — último

Si hay empate de nivel, se evalúa de izquierda a derecha (excepto ** que va de derecha a izquierda). Cuando tengas dudas, usá paréntesis. No es solo por claridad — es por supervivencia. (precio * cantidad) * (1 + iva) es inequívoco; precio * cantidad * 1 + iva da un resultado completamente distinto.

Tip profesional: en código de producción, preferí siempre paréntesis explícitos aunque no sean necesarios. Tu yo del futuro (y tus compañeros de equipo) te lo van a agradecer. resultado = (base * tasa) + comision es más claro que resultado = base * tasa + comision, aunque den lo mismo.

Operadores de comparación

Las comparaciones devuelven True o False. Son la base de toda decisión que tome tu programa:

Operador	Significado	Ejemplo	Resultado
`==`	Igual a	`5 == 5`	`True`
`!=`	Distinto de	`5 != 3`	`True`
`>`	Mayor que	`10 > 5`	`True`
`<`	Menor que	`3 < 7`	`True`
`>=`	Mayor o igual	`5 >= 5`	`True`
`<=`	Menor o igual	`4 <= 3`	`False`

Error clásico: usar = en vez de ==. = es asignación (guardar un valor), == es comparación (preguntar si son iguales). Escribir if saldo = 0 es un error de sintaxis en Python. Lo correcto es if saldo == 0.

Python permite comparaciones encadenadas, algo que otros lenguajes no soportan: 18 <= edad <= 65 verifica que la edad esté en ese rango. Es equivalente a edad >= 18 and edad <= 65 pero mucho más legible.

Operadores lógicos

Los operadores lógicos combinan condiciones booleanas:

and — ambas condiciones deben ser True. True and True → True. Cualquier otra combinación → False.
or — al menos una debe ser True. False or False → False. Cualquier otra combinación → True.
not — invierte el valor. not True → False.

Caso de negocio: para aprobar un crédito en un banco, la regla podría ser: (score >= 650) and (ingreso >= 80000) and (not tiene_deuda_vencida). Las tres condiciones deben cumplirse. Si alguna falla, se rechaza. Eso es un and encadenado con un not.

Python evalúa and/or con evaluación de cortocircuito: si la primera condición de un and es False, ni siquiera mira la segunda (ya sabe que el resultado es False). Esto importa para eficiencia y para evitar errores: if lista and lista[0] > 10 es seguro porque si lista está vacía (falsy), no intenta acceder a lista[0].

Operadores de asignación compuesta

Son atajos para modificar una variable:

Atajo	Equivale a	Uso típico
`x += 5`	`x = x + 5`	Acumular totales en un bucle
`x -= 5`	`x = x - 5`	Descontar de un saldo
`x *= 1.05`	`x = x * 1.05`	Aplicar interés mensual
`x /= 2`	`x = x / 2`	Dividir un monto
`x //= 3`	`x = x // 3`	Repartir en cuotas enteras
`x %= 10`	`x = x % 10`	Quedarse con el último dígito
`x **= 2`	`x = x ** 2`	Elevar al cuadrado

Analogía bancaria: saldo += deposito es como cuando el cajero le suma un depósito a tu saldo. saldo -= extraccion es cuando retirás plata. saldo *= 1.03 es cuando el banco te acredita el interés mensual del plazo fijo.

Ejemplos explicados paso a paso

Ejemplo 1: Aritmética básica y precedencia

Fijate cómo el orden de operaciones afecta el resultado. La línea 4 y 5 dan resultados muy distintos según dónde pongas los paréntesis.

ejemplo_01_aritmetica.pyPython

a, b = 17, 5

print(f"{a} + {b} = {a + b}")       # 22
print(f"{a} - {b} = {a - b}")       # 12
print(f"{a} * {b} = {a * b}")       # 85
print(f"{a} / {b} = {a / b}")       # 3.4 (siempre float!)
print(f"{a} // {b} = {a // b}")     # 3   (parte entera)
print(f"{a} % {b} = {a % b}")       # 2   (resto)
print(f"{a} ** {b} = {a ** b}")     # 1419857

# Precedencia importa:
precio, cantidad, iva = 1500, 3, 0.21
mal  = precio * cantidad * 1 + iva    # 4500.21 (MAL)
bien = precio * cantidad * (1 + iva)  # 5445.0  (BIEN)
print(f"\nSin paréntesis: ${mal}")
print(f"Con paréntesis: ${bien}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Módulo para problemas reales

El operador % resuelve problemas que parecen complicados en una sola línea.

ejemplo_02_modulo.pyPython

# ¿Un número es par o impar?
numero = 42
print(f"{numero} es {'par' if numero % 2 == 0 else 'impar'}")

# Repartir $17,500 entre 4 personas
total = 17500
personas = 4
cada_uno = total // personas
sobrante = total % personas
print(f"\nCada uno: ${cada_uno:,}")
print(f"Sobrante: ${sobrante:,}")

# ¿Es múltiplo de 12? (útil para verificar años completos)
meses = 36
print(f"\n{meses} meses = {meses // 12} años exactos? {'Sí' if meses % 12 == 0 else 'No'}")

# Extraer últimos 2 dígitos de un número
cbu = 2850590940090418135201
ultimos_2 = cbu % 100
print(f"Últimos 2 dígitos del CBU: {ultimos_2}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Interés compuesto y simulación financiera

La potencia (**) convierte una fórmula financiera compleja en una sola línea de Python.

ejemplo_03_interes.pyPython

# Interés compuesto: capital * (1 + tasa)^periodos
capital = 500000      # $500K en un plazo fijo
tna = 0.75            # Tasa Nominal Anual 75%
tem = tna / 12        # Tasa Efectiva Mensual
meses = 6

monto_final = capital * (1 + tem) ** meses
ganancia = monto_final - capital
rendimiento_pct = (ganancia / capital) * 100

print(f"Capital inicial:  ${capital:>12,.2f}")
print(f"TNA:              {tna:.0%}")
print(f"TEM:              {tem:.2%}")
print(f"Plazo:            {meses} meses")
print(f"{'─'*38}")
print(f"Monto final:      ${monto_final:>12,.2f}")
print(f"Ganancia:         ${ganancia:>12,.2f}")
print(f"Rendimiento:      {rendimiento_pct:.1f}%")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Comparaciones y lógicos en evaluación crediticia

Así funciona un motor de decisión simplificado: combina condiciones con and/or/not.

ejemplo_04_scoring.pyPython

# Datos del solicitante
edad = 28
ingreso_mensual = 350000
score = 710
tiene_deuda_vencida = False
antiguedad_laboral = 3  # años

# Reglas de negocio
requisito_edad = 18 <= edad <= 65
requisito_ingreso = ingreso_mensual >= 100000
requisito_score = score >= 650
requisito_deuda = not tiene_deuda_vencida
requisito_laboral = antiguedad_laboral >= 1

# Evaluación
aprobado = (requisito_edad and requisito_ingreso and
            requisito_score and requisito_deuda and
            requisito_laboral)

# Categorización
if aprobado and score >= 750:
    categoria = "Premium"
    tasa = "38% TNA"
elif aprobado and score >= 650:
    categoria = "Estándar"
    tasa = "55% TNA"
else:
    categoria = "Rechazado"
    tasa = "N/A"

print(f"{'═'*40}")
print(f" EVALUACIÓN CREDITICIA")
print(f"{'═'*40}")
print(f" Edad: {edad} ({'✓' if requisito_edad else '✗'})")
print(f" Ingreso: ${ingreso_mensual:,} ({'✓' if requisito_ingreso else '✗'})")
print(f" Score: {score} ({'✓' if requisito_score else '✗'})")
print(f" Deuda vencida: {'No' if not tiene_deuda_vencida else 'Sí'} ({'✓' if requisito_deuda else '✗'})")
print(f" Antigüedad: {antiguedad_laboral} años ({'✓' if requisito_laboral else '✗'})")
print(f"{'─'*40}")
print(f" Resultado: {categoria}")
print(f" Tasa: {tasa}")
print(f"{'═'*40}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Asignación compuesta — simulando movimientos de cuenta

ejemplo_05_cuenta.pyPython

# Simulación de movimientos de una caja de ahorro
saldo = 250000
print(f"Saldo inicial:     ${saldo:>10,}")

saldo += 180000    # Cobro de sueldo
print(f"+ Sueldo:          ${saldo:>10,}")

saldo -= 75000     # Alquiler
print(f"- Alquiler:        ${saldo:>10,}")

saldo -= 45000     # Servicios
print(f"- Servicios:       ${saldo:>10,}")

saldo *= 1.002     # Rendimiento diario
print(f"* Rendimiento:     ${saldo:>10,.2f}")

# Cálculo de proporción gastada
gasto_total = 75000 + 45000
sueldo = 180000
ratio = gasto_total / sueldo * 100
print(f"\nRatio gasto/ingreso: {ratio:.1f}%")
print(f"Estado: {'⚠️ Ajustado' if ratio > 60 else '✓ Saludable'}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Categoría	Operadores	Devuelve
Aritméticos	`+ - * / // % **`	Número (int o float)
Comparación	`== != > < >= <=`	`True` o `False`
Lógicos	`and or not`	`True` o `False`
Asignación	`= += -= = /= //= %= *=`	Nada (modifica la variable)
Identidad	`is, is not`	`True` o `False`
Membresía	`in, not in`	`True` o `False`

Precedencia en una frase: Potencia > Multiplicación/División > Suma/Resta > Comparación > not > and > or. Ante la duda, paréntesis.

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Calculadora aritmética

Dados a = 45 y b = 7, imprimí los 7 resultados aritméticos (suma, resta, multiplicación, división, división entera, módulo y potencia) en líneas separadas. El output debe incluir la línea Resto: 3.

ejercicio_01.pyDebe incluir "Resto: 3"

a = 45
b = 7

# Imprimí las 7 operaciones:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Precio con IVA

Un producto cuesta $8,500. Calculá el precio con IVA (21%) e imprimilo como Con IVA: 10285.0.

ejercicio_02.pyDebe incluir "10285"

precio = 8500
iva = 0.21

# Calculá precio_final e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: ¿Par o impar?

Dado numero = 137, imprimí impar si es impar o par si es par. Usá el operador %.

ejercicio_03.pyDebe incluir "impar"

numero = 137

# Verificá si es par o impar e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Cuota simple de un préstamo

Capital: $1,200,000, tasa anual: 65%, plazo: 12 meses. Calculá el interés total (capital × tasa), el monto total (capital + interés) y la cuota mensual (total / plazo). Imprimí la cuota redondeada a 2 decimales. El output debe incluir 165000.

ejercicio_04.pyDebe incluir "165000"

capital = 1200000
tasa_anual = 0.65
plazo = 12

# Calculá interés, monto total y cuota:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Evaluación booleana

Un cliente tiene score = 620, ingreso = 95000 y deuda_vencida = True. Evaluá si califica para un crédito: score >= 600 AND ingreso >= 80000 AND deuda_vencida sea False. Imprimí Rechazado o Aprobado.

ejercicio_05.pyDebe incluir "Rechazado"

score = 620
ingreso = 95000
deuda_vencida = True

# Evaluá y mostrá resultado:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Distribuir un bono entre empleados

Tenés $2,350,000 para repartir equitativamente entre 7 empleados. Calculá cuánto recibe cada uno (entero, sin centavos) y cuánto sobra. Imprimí ambos valores. El output debe incluir Sobrante: 4.

ejercicio_06.pyDebe incluir "Sobrante: 4"

bono_total = 2350000
empleados = 7

# Calculá con // y % e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Interés compuesto del plazo fijo

Invertís $800,000 en un plazo fijo a TNA 78% por 90 días. La TEM (tasa efectiva mensual) es TNA / 12. Calculá el monto final con interés compuesto a 3 meses. Imprimí el monto final redondeado a 2 decimales. El output debe incluir 966 (parte de los miles).

ejercicio_07.pyDebe incluir "966"

capital = 800000
tna = 0.78
meses = 3

# Calculá TEM, monto final e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Ratio cuota/ingreso con decisión

Un cliente gana $420,000. La cuota del préstamo sería $155,000. Calculá el ratio cuota/ingreso en porcentaje. Si supera 30%, imprimí RECHAZADO - ratio XX.X%. Si no, APROBADO - ratio XX.X%.

ejercicio_08.pyDebe incluir "RECHAZADO"

ingreso = 420000
cuota = 155000

# Calculá ratio e imprimí resultado:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Simulación de caja de ahorro

Empezás con saldo = 500000. Aplicá estos movimientos en orden usando asignación compuesta: +250000 (sueldo), -85000 (alquiler), -32000 (servicios), *1.003 (rendimiento diario), -15000 (compras). Imprimí el saldo final. Debe incluir 619.

ejercicio_09.pyDebe incluir "619"

saldo = 500000

# Aplicá los movimientos con +=, -=, *=:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Motor de evaluación crediticia completo

Evaluá a este cliente: edad=45, ingreso=280000, score=695, deuda_vencida=False, antiguedad=8 años. La cuota del crédito sería $72,000.

Reglas: (1) Edad entre 18-65, (2) Ingreso >= 100000, (3) Score >= 650, (4) Sin deuda vencida, (5) Antigüedad >= 2 años, (6) Ratio cuota/ingreso < 35%.

Imprimí cada validación con ✓ o ✗, el ratio en porcentaje, y si el crédito está APROBADO o RECHAZADO.

ejercicio_10_desafio.pyDebe incluir "APROBADO"

edad = 45
ingreso = 280000
score = 695
deuda_vencida = False
antiguedad = 8
cuota = 72000

# Evaluá las 6 reglas, imprimí cada una, y la decisión final:

Hacé clic en ▶ Ejecutar

Resumen y conexión

Dominás los 4 grupos de operadores: aritméticos, comparación, lógicos y asignación compuesta.
Sabés que / siempre devuelve float, // trunca, % devuelve el resto y ** calcula potencias.
Entendés precedencia y por qué los paréntesis explícitos te salvan bugs.
Podés construir reglas de negocio combinando and, or y not.
Usás asignación compuesta (+=, *=) para simular movimientos de cuenta.

En la siguiente lección (06 · Condicionales) vas a aprender a usar if/elif/else para que tu código tome decisiones basadas en estas comparaciones. Todo lo que practicaste acá de True/False es la base para los condicionales.

Recursos: docs.python.org — Numeric Types · Tabla oficial de precedencia

Hecho con ❤️ por Rodri Gonzalez