Operadores en Python — los errores que todo el mundo comete

Si ya tienes claro lo de las variables y tipos de datos, el siguiente paso natural son los operadores en Python. Son las herramientas que te permiten hacer cálculos, comparar valores y tomar decisiones en tu código.

En este artículo vemos todos los tipos de operadores que necesitas conocer en primero, con los tres errores que más veces vi en clase explicados en detalle.

¿Qué son los operadores en Python?

Un operador es un símbolo que le dice a Python qué operación realizar con uno o más valores. Por ejemplo el + en 3 + 5 es un operador que le dice a Python que sume esos dos valores.

Python tiene varios tipos de operadores. Los veremos de más a menos usados.

Operadores aritméticos en Python — los del día a día

Son los que usarás en casi todos tus programas:

# Suma
print(5 + 3)    # → 8

# Resta
print(5 - 3)    # → 2

# Multiplicación
print(5 * 3)    # → 15

# División normal
print(5 / 2)    # → 2.5  (siempre devuelve float)

# División entera
print(5 // 2)   # → 2    (redondea hacia abajo)

# Módulo (resto de la división)
print(5 % 2)    # → 1

# Potencia
print(5 ** 2)   # → 25

Error clásico 1 — confundir / con //

Este es el error que más veces vi en los ejercicios de FP1. La división normal / en Python siempre devuelve un número decimal (float), aunque el resultado sea exacto:

print(10 / 2)   # → 5.0  NO es 5, es 5.0
print(10 // 2)  # → 5    esto sí es entero

¿Cuándo usar cada una? Usa / cuando necesites decimales, como calcular medias o porcentajes. Usa // cuando necesites un entero exacto, como contar cuántas filas caben en una pantalla o dividir personas en grupos iguales.

Error clásico 2 — el operador % no es porcentaje

Cuando ves % en Python no significa porcentaje, significa módulo, es decir el resto de una división entera. Es uno de los operadores más útiles pero también el más confuso al principio:

print(10 % 3)   # → 1   porque 10 = 3×3 + 1
print(15 % 5)   # → 0   porque 15 = 5×3 + 0
print(7 % 2)    # → 1   porque 7 = 2×3 + 1

¿Para qué sirve en la práctica? Para saber si un número es par o impar:

numero = 7
if numero % 2 == 0:
    print("Es par")
else:
    print("Es impar")

Si el resto de dividir entre 2 es 0, el número es par. Si es 1, es impar. Lo verás en muchísimos ejercicios de FP1.

También sirve para saber si un número es divisible por otro:

print(15 % 3)   # → 0  15 es divisible por 3
print(16 % 3)   # → 1  16 no es divisible por 3

Operadores de comparación — devuelven True o False

Estos operadores comparan dos valores y devuelven un booleano — True si la comparación es cierta, False si no:

print(5 > 3)    # → True
print(5 < 3)    # → False
print(5 >= 5)   # → True
print(5 <= 4)   # → False
print(5 == 5)   # → True   (igual)
print(5 != 3)   # → True   (distinto)

Error clásico 3 — confundir = con ==

Este es probablemente el error más frecuente en primero y el que más tiempo hace perder buscando el fallo:

# = es asignación — guarda un valor en una variable
x = 5           # x ahora vale 5

# == es comparación — comprueba si dos valores son iguales
print(x == 5)   # → True
print(x == 3)   # → False

El problema típico es usar = cuando querías comparar:

# MAL — esto da error de sintaxis en Python
if x = 5:
    print("Es cinco")

# BIEN
if x == 5:
    print("Es cinco")

Python da un error de sintaxis si intentas usar = dentro de un if, así que este error al menos se detecta rápido. Pero en otros contextos puede pasar desapercibido, así que acostúmbrate a usar siempre == para comparar.

Operadores lógicos — combinar condiciones

Cuando necesitas comprobar varias condiciones a la vez usas los operadores lógicos:

# and — ambas condiciones deben ser True
edad = 20
tiene_dni = True
print(edad >= 18 and tiene_dni)   # → True

# or — al menos una condición debe ser True
es_estudiante = True
tiene_descuento = False
print(es_estudiante or tiene_descuento)   # → True

# not — invierte el valor booleano
aprobado = False
print(not aprobado)   # → True

En la práctica los usarás constantemente en los if de tus programas:

nota = 6.5
asistencia = 80

if nota >= 5 and asistencia >= 75:
    print("Aprobado")
else:
    print("Suspenso")

Operadores de asignación compuesta — el atajo que ahorra tiempo

Python tiene una versión compacta de los operadores aritméticos combinados con la asignación. Son muy útiles en bucles:

x = 10

x += 5    # equivale a x = x + 5  → x ahora vale 15
x -= 3    # equivale a x = x - 3  → x ahora vale 12
x *= 2    # equivale a x = x * 2  → x ahora vale 24
x /= 4    # equivale a x = x / 4  → x ahora vale 6.0
x //= 2   # equivale a x = x // 2 → x ahora vale 3.0
x **= 2   # equivale a x = x ** 2 → x ahora vale 9.0
x %= 4    # equivale a x = x % 4  → x ahora vale 1.0

El más usado con diferencia es += — lo verás en todos los acumuladores y contadores de FP1.

Precedencia de operadores — el orden importa

Python sigue un orden de prioridad para evaluar las operaciones, igual que en matemáticas. De mayor a menor prioridad:

# 1. Paréntesis        ( )
# 2. Potencia          **
# 3. Multiplicación, división, módulo   * / // %
# 4. Suma y resta      + -
# 5. Comparación       > < >= <= == !=
# 6. not
# 7. and
# 8. or

En la práctica esto significa que estas dos expresiones dan resultados diferentes:

print(2 + 3 * 4)      # → 14  (primero 3*4=12, luego 2+12)
print((2 + 3) * 4)    # → 20  (primero 2+3=5, luego 5*4)

La regla de oro: cuando tengas dudas, usa paréntesis. Hacen el código más legible y evitan errores de precedencia. Es mejor poner un paréntesis de más que uno de menos.

Visualízalo con Python Tutor

Para entender cómo Python evalúa una expresión paso a paso, copia esto en pythontutor.com y ejecútalo línea por línea:

a = 10
b = 3

suma = a + b
resta = a - b
division = a / b
division_entera = a // b
modulo = a % b
potencia = a ** b

print(suma, resta, division, division_entera, modulo, potencia)

Verás cómo Python crea cada variable con su valor en memoria. Especialmente útil para ver la diferencia entre / y //.

Resumen rápido

Los operadores en Python se dividen en aritméticos, comparación, lógicos y de asignación compuesta.

• + - * / // % ** — operadores aritméticos
• / siempre devuelve float — usa // para división entera
• % es el resto de la división — no es porcentaje
• = asigna, == compara — no los confundas
• and or not — operadores lógicos para combinar condiciones
• += -= *= — atajos de asignación compuesta
• Cuando dudes del orden de evaluación — usa paréntesis

En el próximo artículo practicamos todos estos operadores con programas reales en VS Code.