Operadores en Python: Guía completa 2025 [Aritméticos, Lógicos y más]

¿Qué son los operadores en Python?

Los operadores son símbolos especiales que le indican al intérprete de Python que realice operaciones específicas sobre uno o más valores. Son los bloques fundamentales que te permiten manipular datos, tomar decisiones y construir la lógica de tus programas.

Imagina los operadores como las herramientas de un carpintero: así como un martillo clava y una sierra corta, los operadores realizan acciones específicas con tus datos. Algunos suman números, otros comparan valores, y algunos te permiten combinar condiciones lógicas complejas.

Python incluye varios tipos de operadores:

• Operadores aritméticos – para realizar cálculos matemáticos
• Operadores de comparación – para comparar valores
• Operadores lógicos – para combinar condiciones
• Operadores de asignación – para asignar y modificar valores
• Operadores de identidad – para comparar la identidad de objetos
• Operadores de pertenencia – para verificar si un valor está en una secuencia

A lo largo de este artículo, exploraremos cada tipo con ejemplos prácticos que puedes ejecutar en tu intérprete de Python.

Operadores aritméticos en Python

Los operadores aritméticos te permiten realizar operaciones matemáticas básicas y avanzadas. Python incluye todos los operadores que esperarías encontrar en una calculadora, más algunos especiales que lo hacen especialmente potente.

Tabla de operadores aritméticos

Ejemplo básico – Calculadora simple

Vamos a crear una calculadora básica que realiza operaciones aritméticas sobre dos números:

>>> price = 99.99
>>> quantity = 3
>>> subtotal = price * quantity
>>> subtotal
299.97
>>> tax_rate = 0.21  # 21% IVA
>>> total = subtotal * (1 + tax_rate)
>>> total
362.9637
>>> round(total, 2)  # Redondear a 2 decimales
362.96

>>> price = 99.99
>>> quantity = 3
>>> subtotal = price * quantity
>>> subtotal
299.97
>>> tax_rate = 0.21  # 21% IVA
>>> total = subtotal * (1 + tax_rate)
>>> total
362.9637
>>> round(total, 2)  # Redondear a 2 decimales
362.96

División entera vs división normal

Una característica única que confunde a muchos principiantes es la diferencia entre / y //:

>>> kilometers = 100
>>> hours = 3
>>> speed_exact = kilometers / hours
>>> speed_exact
33.333333333333336
>>> speed_rounded = kilometers // hours
>>> speed_rounded
33

La división normal (/) siempre devuelve un float, incluso si el resultado es un número entero:

>>> 10 / 5
2.0
>>> 10 // 5
2

Caso real – Cálculo de IVA en un carrito de compra

Imaginemos que estamos construyendo un e-commerce y necesitamos calcular el precio final después de aplicar un descuento y añadir el IVA:

>>> base_price = 150.00
>>> discount_percent = 15
>>> discount_amount = base_price * (discount_percent / 100)
>>> discount_amount
22.5
>>> price_after_discount = base_price - discount_amount
>>> price_after_discount
127.5
>>> vat_rate = 0.21
>>> final_price = price_after_discount * (1 + vat_rate)
>>> final_price
154.275
>>> round(final_price, 2)
154.28

Tip Pro: El operador módulo (%) es extremadamente útil para verificar si un número es par o impar:

>>> number = 42
>>> number % 2
0  # Si el resto es 0, el número es par
>>> number = 43
>>> number % 2
1  # Si el resto es 1, el número es impar

Operadores de comparación en Python

Los operadores de comparación (también llamados operadores relacionales) permiten comparar valores y siempre devuelven un valor booleano: True o False. Son fundamentales para construir condiciones en tus programas.

Tabla de operadores de comparación

Ejemplo básico – Comparaciones simples

Veamos cómo funcionan las comparaciones con diferentes valores:

>>> age = 18
>>> age >= 18
True
>>> age < 21
True
>>> age == 18
True
>>> age != 25
True

Caso real – Validación de edad para acceso

Supongamos que estamos construyendo un sistema de control de acceso que verifica si un usuario puede entrar a un sitio web restringido:

>>> user_age = 16
>>> minimum_age = 18
>>> can_access = user_age >= minimum_age
>>> can_access
False
>>> user_age = 20
>>> can_access = user_age >= minimum_age
>>> can_access
True

Comparaciones con strings

Las comparaciones también funcionan con cadenas de texto, usando orden lexicográfico (alfabético):

>>> "apple" < "banana"
True
>>> "python" == "Python"
False  # Python es case-sensitive
>>> "python".casefold() == "Python".casefold()
True

Nota importante sobre comparación de strings: Es recomendable usar .casefold() en lugar de .lower() cuando compares strings para hacer comparaciones insensibles a mayúsculas/minúsculas. El método casefold() es más agresivo y funciona correctamente con más idiomas y caracteres especiales:

>>> # Con caracteres alemanes
>>> "straße".lower() == "STRASSE".lower()
False
>>> "straße".casefold() == "STRASSE".casefold()
True

Cuidado con el operador de asignación: Un error común es confundir = (asignación) con == (comparación):

>>> x = 5  # Esto ASIGNA el valor 5 a x
>>> x == 5  # Esto COMPARA si x es igual a 5
True

Operadores lógicos en Python (and, or, not)

Los operadores lógicos te permiten combinar múltiples condiciones y crear expresiones más complejas. Python tiene tres operadores lógicos principales: and, or y not.

Tabla de verdad de operadores lógicos

Operador AND

Operador OR

Operador NOT

Ejemplo básico – Combinando condiciones

Veamos cómo combinar múltiples condiciones para crear expresiones lógicas:

>>> age = 25
>>> has_license = True
>>> age >= 18 and has_license
True
>>> age < 18 or has_license
True
>>> not has_license
False

Caso real – Sistema de permisos de usuario

Imaginemos que estamos desarrollando un sistema de autenticación donde necesitamos verificar múltiples condiciones antes de permitir el acceso:

>>> user_role = "admin"
>>> is_authenticated = True
>>> is_active = True
>>> 
>>> # Usuario puede acceder si está autenticado Y activo
>>> can_login = is_authenticated and is_active
>>> can_login
True
>>> 
>>> # Usuario puede editar si es admin O moderador
>>> is_admin = user_role == "admin"
>>> is_moderator = user_role == "moderator"
>>> can_edit = is_admin or is_moderator
>>> can_edit
True
>>> 
>>> # Usuario está bloqueado si NO está activo
>>> is_blocked = not is_active
>>> is_blocked
False

Precedencia de operadores lógicos

Es importante conocer el orden en que Python evalúa los operadores:

1. not (mayor precedencia)
2. and
3. or (menor precedencia)

>>> True or True and False
True  # Se evalúa como: True or (True and False)
>>> (True or True) and False
False  # Los paréntesis cambian el orden

Tip Pro sobre cortocircuito en evaluación:

Python usa «evaluación perezosa» con and y or:

>>> False and print("Esto no se ejecuta")
False
>>> True or print("Esto tampoco se ejecuta")
True
>>> False or print("Esto SÍ se ejecuta")
Esto SÍ se ejecuta

Esto es útil para evitar errores:

>>> users = []
>>> # Esto daría error si users está vacío y no usáramos 'and'
>>> users and users[0]  # No intenta acceder a users[0] si está vacío
False

Operadores de asignación en Python

Los operadores de asignación te permiten asignar valores a variables de forma eficiente. Python ofrece versiones compactas que combinan una operación aritmética con la asignación.

Tabla de operadores de asignación

Ejemplo práctico – Contador de visitas

Veamos cómo usar operadores de asignación compuestos para mantener un contador simple:

>>> page_views = 0
>>> # Primera visita
>>> page_views += 1
>>> page_views
1
>>> # Segunda visita
>>> page_views += 1
>>> page_views
2
>>> # 10 visitas más
>>> page_views += 10
>>> page_views
12

Caso real – Aplicar descuento progresivo

Imagina que estás desarrollando un sistema de precios con descuentos progresivos donde cada descuento se aplica sobre el precio ya rebajado:

>>> product_price = 100.0
>>> # Primer descuento: 10%
>>> product_price *= 0.9  # Equivale a: product_price = product_price * 0.9
>>> product_price
90.0
>>> # Segundo descuento: 5% adicional
>>> product_price *= 0.95
>>> product_price
85.5
>>> # Redondear el precio
>>> product_price = round(product_price, 2)
>>> product_price
85.5

Llevando los operadores al siguiente nivel

En el libro Python a fondo encontrarás muchos ejercicios resueltos con operadores en contextos reales: validaciones, cálculos financieros, análisis de datos y más.

Ver el libro

Operadores de identidad y pertenencia

Python tiene dos categorías especiales de operadores que van más allá de las operaciones matemáticas y lógicas básicas.

Operadores de identidad: is e is not

Los operadores is e is not comprueban si dos variables apuntan al mismo objeto en memoria, no solo si tienen el mismo valor.

>>> list_a = [1, 2, 3]
>>> list_b = [1, 2, 3]
>>> list_c = list_a
>>> 
>>> list_a == list_b  # Mismo valor
True
>>> list_a is list_b  # ¿Mismo objeto?
False
>>> list_a is list_c  # ¿Mismo objeto?
True

Diferencia entre == e is:

• == compara valores (contenido)
• is compara identidad (ubicación en memoria)

>>> x = 1000
>>> y = 1000
>>> x == y
True
>>> x is y
False  # Son objetos diferentes en memoria
>>> 
>>> # Excepción: números pequeños y strings son cached
>>> a = 5
>>> b = 5
>>> a is b
True  # Python optimiza números pequeños

Operadores de pertenencia: in y not in

Los operadores in y not in verifican si un valor está presente en una secuencia (lista, tupla, string, set, etc.).

Nota importante: Según el PEP 8 (la guía de estilo oficial de Python), debes usar siempre not in en lugar de not ... in para verificar la ausencia de un elemento:

>>> allowed_users = ["alice", "bob", "charlie"]
>>> # Forma correcta (PEP 8)
>>> "david" not in allowed_users
True
>>> # Forma incorrecta (evitar)
>>> not "david" in allowed_users  # Funciona pero no es pythónico
True
>>> 
>>> # Para verificar presencia
>>> "alice" in allowed_users
True

Caso real – Validación de email

Supongamos que estamos validando direcciones de email y verificando que no pertenezcan a dominios bloqueados:

>>> email = "usuario@ejemplo.com"
>>> "@" in email
True
>>> "." in email
True
>>> # Validación básica
>>> valid_email = "@" in email and "." in email
>>> valid_email
True
>>> 
>>> # Verificar dominio prohibido
>>> blocked_domains = ["spam.com", "fake.com"]
>>> email_domain = email.split("@")[1]
>>> email_domain
'ejemplo.com'
>>> email_domain not in blocked_domains
True

Operador ternario en Python

El operador ternario (también llamado expresión condicional) te permite escribir una sentencia if-else en una sola línea. Es especialmente útil para asignaciones condicionales simples.

Sintaxis

valor_si_true if condicion else valor_si_false

Ejemplo básico

>>> age = 20
>>> status = "adult" if age >= 18 else "minor"
>>> status
'adult'
>>> 
>>> age = 15
>>> status = "adult" if age >= 18 else "minor"
>>> status
'minor'

Comparación con if-else tradicional

Versión tradicional:

>>> score = 85
>>> if score >= 60:
...     result = "pass"
... else:
...     result = "fail"
>>> result
'pass'

Versión con operador ternario:

>>> score = 85
>>> result = "pass" if score >= 60 else "fail"
>>> result
'pass'

Caso real – Calcular precio con descuento

Veamos cómo aplicar descuentos condicionales de forma elegante en un sistema de ventas:

>>> quantity = 15
>>> unit_price = 10.0
>>> # Descuento del 10% si compra más de 10 unidades
>>> price_per_unit = unit_price * 0.9 if quantity > 10 else unit_price
>>> price_per_unit
9.0
>>> total_price = price_per_unit * quantity
>>> total_price
135.0

Caso avanzado – Operadores ternarios anidados

Aunque es posible anidar operadores ternarios, debes tener cuidado con la legibilidad:

>>> score = 75
>>> grade = "A" if score >= 90 else "B" if score >= 80 else "C" if score >= 70 else "D" if score >= 60 else "F"
>>> grade
'C'

Tip Pro: Si tu operador ternario se vuelve muy complejo o necesitas más de 2 niveles de anidación, es mejor usar un if-elif-else tradicional para mantener la legibilidad del código.

Cuándo NO usar el operador ternario:

# Evitar: demasiado complejo
result = (x * 2 if x > 0 else x * -1) if x != 0 else 0

# Mejor: usar if-else tradicional
if x == 0:
    result = 0
elif x > 0:
    result = x * 2
else:
    result = x * -1

Expresiones lógicas en programación

Las expresiones lógicas son combinaciones de valores, variables y operadores que Python evalúa para producir un resultado booleano (True o False). Son la base de la toma de decisiones en tus programas.

Construyendo expresiones complejas

Puedes combinar múltiples operadores para crear expresiones más sofisticadas:

>>> age = 25
>>> income = 35000
>>> credit_score = 720
>>> 
>>> # Expresión compleja para aprobación de préstamo
>>> eligible = age >= 21 and income >= 30000 and credit_score >= 650
>>> eligible
True

Caso real – Sistema de descuentos multinivel

Imaginemos que estamos desarrollando un sistema de e-commerce donde los descuentos se acumulan según diferentes criterios: membresía, monto de compra y frecuencia:

>>> purchase_amount = 150
>>> is_member = True
>>> purchases_this_year = 8
>>> 
>>> # Descuento base del 5% para miembros
>>> has_member_discount = is_member
>>> 
>>> # Descuento adicional del 10% si compra más de 100€
>>> has_amount_discount = purchase_amount > 100
>>> 
>>> # Descuento especial del 15% si es cliente frecuente (>5 compras)
>>> has_frequent_discount = purchases_this_year > 5
>>> 
>>> # Calcular descuento total
>>> discount_rate = 0
>>> if has_member_discount:
...     discount_rate += 0.05
>>> if has_amount_discount:
...     discount_rate += 0.10
>>> if has_frequent_discount:
...     discount_rate += 0.15
>>> 
>>> discount_rate
0.3
>>> final_price = purchase_amount * (1 - discount_rate)
>>> final_price
105.0

Usando paréntesis para claridad

Aunque Python tiene precedencia de operadores, usar paréntesis hace tu código más legible:

>>> age = 25
>>> has_license = True
>>> years_experience = 3
>>> 
>>> # Sin paréntesis (funciona pero es menos claro)
>>> can_rent_car = age >= 21 and has_license and years_experience >= 2
>>> can_rent_car
True
>>> 
>>> # Con paréntesis (más claro)
>>> can_rent_car = (age >= 21) and has_license and (years_experience >= 2)
>>> can_rent_car
True

Caso avanzado – Validación de formulario de registro

Vamos a construir un validador completo para un formulario de registro de usuarios, verificando múltiples condiciones:

>>> username = "john_doe_2024"
>>> password = "SecurePass123!"
>>> email = "john@example.com"
>>> age = 17
>>> accepts_terms = True
>>> 
>>> # Validar username (entre 5 y 20 caracteres)
>>> valid_username = 5 <= len(username) <= 20
>>> 
>>> # Validar password (al menos 8 caracteres y contiene números)
>>> valid_password = len(password) >= 8 and any(char.isdigit() for char in password)
>>> 
>>> # Validar email (contiene @ y .)
>>> valid_email = "@" in email and "." in email
>>> 
>>> # Validar edad (mayor de 18)
>>> valid_age = age >= 18
>>> 
>>> # Usuario puede registrarse si TODO es válido
>>> can_register = valid_username and valid_password and valid_email and valid_age and accepts_terms
>>> 
>>> can_register
False  # Porque age < 18
>>> 
>>> # Verificar qué falló
>>> if not valid_age:
...     print("Error: Debes ser mayor de 18 años")
Error: Debes ser mayor de 18 años

Precedencia completa de operadores en Python

Cuando combinas múltiples operadores, Python los evalúa en este orden (de mayor a menor precedencia):

1. ** (Potencia)
2. +x, -x, ~x (Unarios)
3. *, /, //, % (Multiplicación, división)
4. +, - (Suma, resta)
5. <<, >> (Desplazamientos de bits)
6. & (AND bit a bit)
7. ^ (XOR bit a bit)
8. | (OR bit a bit)
9. ==, !=, >, >=, <, <=, is, is not, in, not in (Comparaciones)
10. not (NOT lógico)
11. and (AND lógico)
12. or (OR lógico)

>>> # Ejemplo de precedencia
>>> result = 5 + 3 * 2
>>> result
11  # Se evalúa como: 5 + (3 * 2)
>>> 
>>> # Usar paréntesis para cambiar el orden
>>> result = (5 + 3) * 2
>>> result
16
>>> 
>>> # Precedencia con operadores lógicos
>>> True or False and False
True  # Se evalúa como: True or (False and False)
>>> 
>>> (True or False) and False
False

Puntos clave para recordar

Los operadores son herramientas fundamentales que usarás en cada programa Python que escribas. Desde simples cálculos aritméticos hasta complejas expresiones lógicas, dominar los operadores te permite:

• Realizar cálculos matemáticos precisos
• Comparar valores y tomar decisiones
• Combinar condiciones complejas
• Escribir código más limpio y eficiente
• Validar datos de entrada
• Construir la lógica de tus aplicaciones

Pepitas de conocimiento

1. División entera (//) vs división normal (/) – Elige según necesites el cociente entero o el resultado exacto
2. == vs is – Usa == para comparar valores e is para comparar identidad de objetos
3. Precedencia de operadores – Los operadores lógicos se evalúan en orden: not → and → or
4. Operador ternario – Úsalo para asignaciones condicionales simples, evita anidaciones complejas
5. Paréntesis – Siempre que dudes, usa paréntesis para hacer tu código más legible
6. not in según PEP 8 – Usa siempre not in en lugar de not ... in para verificar ausencia
7. .casefold() vs .lower() – Prefiere casefold() para comparaciones de strings insensibles a mayúsculas

Próximos pasos

Ahora que dominas los operadores, es momento de aprender a usarlos para controlar el flujo de tus programas. En el siguiente artículo descubrirás cómo tomar decisiones con estructuras condicionales.

Siguiente paso: Domina las estructuras de control

Ahora que conoces los operadores, aprende a tomar decisiones en tu código:

if, elif y else en Python – Guía completa

¿Te ha gustado este artículo? Compártelo con otros pythonistas que estén empezando su camino en la programación.

Déjanos un comentario con tus dudas o casos de uso interesantes con operadores.

Para profundizar más con ejercicios avanzados, ejemplos profesionales y proyectos reales, no te pierdas Python a fondo.