Operadores en Python: guía completa con ejemplos reales

Hay una frase que repito siempre que explico Python a alguien que viene de otro lenguaje: "los operadores son el vocabulario básico de cualquier programa". No exagero. Sin operadores no puedes calcular, no puedes comparar, no puedes tomar decisiones. Son literalmente la gramática con la que le hablas al intérprete.

Lo bueno es que en Python los operadores son intuitivos y, en muchos casos, se leen casi como inglés natural. if user in admins o if resultado is not None son expresiones que cualquier persona entiende sin necesidad de comentarios. Eso no es casualidad: Guido van Rossum diseñó Python para que el código fuera legible por humanos, y los operadores son una de las partes donde más se nota.

En esta lección vamos a ver los seis grupos principales de operadores, cómo funciona la precedencia (quién manda cuando hay varios en la misma línea), los errores que comete absolutamente todo el mundo al principio, y algunos trucos que me habría encantado conocer antes.

➕ Operadores aritméticos: más que sumar y restar

Los más obvios. Pero hay alguno que siempre pilla desprevenida a la gente que viene de lenguajes como Java o JavaScript.

# Los seis operadores aritméticos
10 + 3    # → 13     (suma)
10 - 3    # → 7      (resta)
10 * 3    # → 30     (multiplicación)
10 / 3    # → 3.333  (división — siempre float en Python 3)
10 // 3   # → 3      (división entera — parte entera del resultado)
10 % 3    # → 1      (módulo — resto de la división)
2 ** 10   # → 1024   (potenciación)

El que más sorprende es el /. En Python 2, 10 / 3 daba 3 (comportamiento entero). En Python 3, siempre devuelve 3.3333.... Si en 2026 sigues encontrando tutoriales que dicen que la división de enteros devuelve entero, están describiendo Python 2. Ciérralos.

El operador + y * también funcionan con cadenas de texto, aunque con lógica diferente:

"Hola" + " " + "mundo"   # → "Hola mundo"  (concatenación)
"ja" * 3                 # → "jajaja"      (repetición)

✂️ División entera y módulo: los dos operadores olvidados más útiles

Voy a dedicarles una sección aparte porque merecen respeto. Son los operadores que la gente ignora al principio y luego usa constantemente en cuanto empieza a programar cosas reales.

División entera //

Devuelve la parte entera del cociente, descartando los decimales. Siempre redondea hacia abajo (hacia el infinito negativo), no hacia cero:

7 // 2     # → 3    (no 4)
-7 // 2    # → -4   (no -3, porque redondea hacia abajo)
15.0 // 4  # → 3.0  (si algún operando es float, devuelve float)

El uso más habitual: cálculos de paginación. Si tienes 47 artículos y quieres 10 por página, 47 // 10 te da 4 páginas completas. Luego compruebas si 47 % 10 > 0 para saber si necesitas una página adicional.

Módulo %

Devuelve el resto de la división. Más útil de lo que parece. Mis tres usos favoritos:

# 1. Par o impar
def es_par(n):
    return n % 2 == 0

# 2. Rotar índices (útil para sliders, carruseles, turnos)
def siguiente(indice_actual, total):
    return (indice_actual + 1) % total
# siguiente(4, 5) → 0  (vuelve al inicio)

# 3. Separar horas, minutos, segundos
segundos_totales = 3723
horas   = segundos_totales // 3600          # → 1
minutos = (segundos_totales % 3600) // 60   # → 2
segs    = segundos_totales % 60             # → 3
# → 1h 2m 3s

🔍 Operadores de comparación: el arte de hacer preguntas

Los operadores de comparación siempre devuelven un booleano (True o False). Son la base de cualquier condición.

5 == 5      # → True    (¿son iguales?)
5 != 3      # → True    (¿son distintos?)
5 > 3       # → True    (¿mayor que?)
5 < 3       # → False   (¿menor que?)
5 >= 5      # → True    (¿mayor o igual?)
5 <= 4      # → False   (¿menor o igual?)

Una característica que sorprende a la gente que viene de Java o C#: en Python puedes encadenar comparaciones, igual que en matemáticas:

# En Java necesitarías: if (edad >= 18 && edad <= 65)
# En Python:
if 18 <= edad <= 65:
    print("Edad laboral activa")

# Funciona con cualquier combinación
if 0 < x < 100:
    pass

if a < b < c < d:
    pass

Es más limpio y más legible. Úsalo.

🔗 Operadores lógicos: and, or, not (y el cortocircuito)

Los operadores lógicos combinan condiciones. Son sencillos en apariencia, pero tienen un comportamiento que marca la diferencia cuando escribes código robusto: el cortocircuito de evaluación.

True and True    # → True
True and False   # → False
False and True   # → False  ← Python NI EVALÚA "True" — se para aquí

True or False    # → True   ← Python NI EVALÚA "False" — ya sabe el resultado
False or True    # → True
False or False   # → False

not True         # → False
not False        # → True

¿Qué es el cortocircuito y por qué importa?

Con and: si el primer operando es falsy, Python devuelve ese valor sin evaluar el segundo. Con or: si el primer operando es truthy, Python devuelve ese valor sin evaluar el segundo.

Esto no es solo una curiosidad teórica. Te salva de errores en la práctica:

# Sin cortocircuito, si conexion es None esto daría AttributeError
if conexion is not None and conexion.esta_activa():
    enviar_datos()

# Con or, podemos dar un valor por defecto de forma elegante
nombre = usuario.nombre or "Anónimo"
# Si usuario.nombre es "" o None o 0, devuelve "Anónimo"

📥 Operadores de asignación: el = y sus primos más perezosos

El operador básico = asigna un valor a una variable. Pero Python tiene una familia completa de operadores de asignación compuesta que ahorran escritura y, en algunos casos, son más eficientes:

x = 10          # asignación básica

x += 5          # equivale a: x = x + 5   → x es 15
x -= 3          # equivale a: x = x - 3   → x es 12
x *= 2          # equivale a: x = x * 2   → x es 24
x //= 5         # equivale a: x = x // 5  → x es 4
x **= 3         # equivale a: x = x ** 3  → x es 64
x %= 10         # equivale a: x = x % 10  → x es 4

# Con strings también:
mensaje = "Hola"
mensaje += ", mundo"    # → "Hola, mundo"

# Con listas:
frutas = ["manzana"]
frutas += ["pera", "kiwi"]   # añade elementos a la lista

El más usado con diferencia es +=, que aparece en casi todos los bucles. En Python no existe el operador ++ de C/Java. Si vienes de esos lenguajes, i++ no funciona: tienes que escribir i += 1.

El operador walrus := (Python 3.8+)

El operador de asignación expresión, popularmente conocido como walrus operator (morsa, por su parecido con los ojos y colmillos del animal), permite asignar y usar un valor dentro de una expresión:

# Sin walrus — código repetitivo
datos = archivo.read(1024)
while datos:
    procesar(datos)
    datos = archivo.read(1024)

# Con walrus — más limpio
while chunk := archivo.read(1024):
    procesar(chunk)

🪪 Identidad y pertenencia: is e in

Estos dos grupos son mi parte favorita del sistema de operadores de Python. No existen de esta forma en la mayoría de lenguajes, y cuando los descubres te pregunta por qué no están en todos.

Operadores de identidad: is y is not

Comparan si dos variables apuntan al mismo objeto en memoria, no si tienen el mismo valor:

a = [1, 2, 3]
b = [1, 2, 3]
c = a

a == b      # → True   (mismo contenido)
a is b      # → False  (objetos distintos en memoria)
a is c      # → True   (c apunta al mismo objeto que a)

# El uso más importante: comparar con None
def procesar(valor=None):
    if valor is None:       # ✅ correcto
        return "sin valor"
    if valor == None:       # ❌ funciona pero no es idiomático
        return "sin valor"

Hay una trampa: Python hace caché de algunos objetos pequeños (enteros del -5 al 256, strings cortos sin espacios). Eso hace que a is b pueda ser True aunque sean variables distintas, si su valor está en el rango cacheado. Nunca uses is para comparar valores: úsalo solo para comprobar identidad con None, True o False.

Operadores de pertenencia: in y not in

Comprueban si un elemento está contenido en una secuencia (lista, tupla, string, diccionario, conjunto...):

"py" in "python"          # → True
"x" not in "python"       # → True

3 in [1, 2, 3, 4]         # → True
10 in {1, 2, 3}           # → False  (set — búsqueda en O(1))

# En diccionarios, in comprueba las CLAVES
"nombre" in {"nombre": "Ana", "edad": 30}   # → True
"Ana" in {"nombre": "Ana", "edad": 30}      # → False

# El uso más natural — código casi como inglés
ADMINS = {"ana", "pedro", "luis"}
if usuario in ADMINS:
    mostrar_panel_admin()

⚖️ Precedencia: quién manda cuando no hay paréntesis

Si escribes 2 + 3 * 4, Python devuelve 14, no 20. La multiplicación tiene mayor precedencia que la suma, igual que en matemáticas. Pero las reglas completas van más allá de lo que aprendiste en el colegio.

Esta es la jerarquía completa, de mayor a menor prioridad:

Algunos ejemplos que sorprenden:

not 5 > 3         # → False   (primero evalúa 5>3=True, luego not True=False)
2 + 3 > 4 and 1 < 2   # → True  (suma → comparación → and)
True or False and False   # → True  (and tiene más prioridad que or)
# equivale a: True or (False and False) = True or False = True

El consejo más valioso que te puedo dar sobre precedencia: no la memorices, usa paréntesis. No es debilidad ni señal de que no sabes Python. Al contrario: es señal de que priorizas la legibilidad sobre el exhibicionismo técnico.

# Legible, sin ambigüedad
resultado = (a + b) * (c - d)
valido = (edad >= 18) and (not suspendido)

# Válido pero innecesariamente críptico
resultado = a + b * c - d    # ¿qué operación querías?

🎯 Trucos y patrones con operadores

Con los años he ido acumulando un repertorio de usos de operadores que no se suelen explicar en los tutoriales básicos pero que aparecen constantemente en código real.

Intercambio de variables sin variable temporal

a, b = 10, 20
a, b = b, a       # swap en una línea
# Ahora a=20, b=10

# En otros lenguajes necesitas:
# temp = a; a = b; b = temp

Valor por defecto con or

nombre = input("Tu nombre: ") or "Anónimo"
# Si el usuario no escribe nada, nombre = "Anónimo"

config = configuracion_usuario or configuracion_por_defecto

Guardia con and

# Ejecutar algo solo si una condición se cumple
debug and print("Estado:", variable)
# Si debug=False, el print nunca se ejecuta

Módulo para ciclos perfectos

# Índice que vuelve a 0 cuando llega al final
COLORES = ["rojo", "verde", "azul"]
for i in range(10):
    color = COLORES[i % len(COLORES)]
    print(color)
# rojo, verde, azul, rojo, verde, azul, ...

Potencia para escalas

# Cálculo de bytes a megabytes
bytes_en_1_mb = 1024 ** 2    # → 1,048,576
bytes_en_1_gb = 1024 ** 3    # → 1,073,741,824

🐛 Errores clásicos con operadores (que todos cometemos)

Llevo años viendo los mismos errores una y otra vez. Aquí están los más frecuentes para que no pierdas tiempo depurándolos.

1. = en lugar de ==

# Error de sintaxis en Python (en C sería válido y muy peligroso):
if x = 5:   # SyntaxError: invalid syntax
    pass

# Correcto:
if x == 5:
    pass

2. Comparar con == en lugar de is para None

resultado = None
if resultado == None:    # funciona, pero el linter lo marcará
    pass
if resultado is None:    # ✅ idiomático y correcto
    pass

3. Confundir is con == para enteros fuera del rango cacheado

a = 256
b = 256
a is b    # → True  (Python cachea hasta 256)

a = 257
b = 257
a is b    # → False  (fuera del caché, son objetos distintos)
a == b    # → True   (mismo valor)
# Conclusión: nunca uses is para comparar valores numéricos

4. Olvidar que / siempre devuelve float

total = 10
por_pagina = 5
paginas = total / por_pagina     # → 2.0  (float!)
paginas = total // por_pagina    # → 2    (int — esto es lo que quieres)

# El problema aparece cuando usas el resultado como índice:
lista[total / 2]    # TypeError: list indices must be integers
lista[total // 2]   # ✅ correcto

5. ** asocia a la derecha, no a la izquierda

2 ** 3 ** 2     # → 512   (evalúa como 2 ** (3**2) = 2**9 = 512)
(2 ** 3) ** 2   # → 64    (si esto era lo que querías, pon paréntesis)

✅ Resumen y próximos pasos

Has visto los seis grupos de operadores de Python con ejemplos reales, las reglas de precedencia y los errores más habituales. Para consolidar:

• Los aritméticos (+, -, *, /, //, %, **) son tu caja de herramientas matemática. Recuerda que / siempre devuelve float.
• Los de comparación (==, !=, <, >, <=, >=) siempre devuelven True o False. Puedes encadenarlos.
• Los lógicos (and, or, not) combinan condiciones y usan cortocircuito.
• Los de asignación compuesta (+=, -=, etc.) son atajos que usarás todos los días.
• is e is not comparan identidad (mismo objeto), no valor. Úsalos solo para None.
• in y not in hacen el código más legible. En set son más rápidos que en list.
• Ante la duda con precedencia: pon paréntesis.

En la próxima lección entramos en entrada y salida: cómo Python lee datos del usuario con input() y los muestra con print() de manera avanzada. Todo lo que has aprendido aquí sobre operadores te va a hacer falta desde el primer ejemplo.

❓ Preguntas frecuentes sobre operadores en Python