Operadores Python: aritmética, lógica y comparación

Los operadores en Python permiten realizar cálculos, comparar valores, combinar condiciones, actualizar variables, comprobar pertenencia e identidad y trabajar con bits o conjuntos. Comprender su precedencia y el tipo de dato sobre el que actúan evita muchos errores difíciles de detectar.

En esta guía aprenderás operadores aritméticos, de comparación, asignación, lógicos, pertenencia, identidad, bit a bit y condicionales. La referencia oficial de expresiones documenta su comportamiento, y el módulo estándar operator ofrece equivalentes funcionales para muchas operaciones.

Operadores aritméticos

a = 10
b = 3

print(a + b)   # suma
print(a - b)   # resta
print(a * b)   # multiplicación
print(a / b)   # división real
print(a // b)  # división entera
print(a % b)   # resto
print(a ** b)  # potencia

La división con / devuelve un número de punto flotante. // aplica división de piso, que puede sorprender con números negativos:

print(-10 // 3)  # -4
print(-10 % 3)   # 2

El cociente y el resto mantienen la relación a == (a // b) * b + (a % b).

Precedencia aritmética

resultado = 2 + 3 * 4
resultado_con_parentesis = (2 + 3) * 4

print(resultado)
print(resultado_con_parentesis)

La multiplicación se evalúa antes que la suma. Utiliza paréntesis cuando hagan más clara la intención, incluso si conoces la precedencia.

Operadores de comparación

edad = 25

print(edad == 25)
print(edad != 18)
print(edad > 20)
print(edad >= 25)
print(edad < 30)
print(edad <= 25)

Las comparaciones devuelven valores booleanos. La guía de booleanos en Python explica True, False y valores truthy.

Comparaciones encadenadas

edad = 30

if 18 <= edad < 65:
    print("Edad laboral")

La expresión es equivalente a comprobar ambos límites con and, pero evalúa la variable central una sola vez.

Comparar números de punto flotante

print(0.1 + 0.2 == 0.3)

El resultado puede ser falso por la representación binaria de los floats. Para comparaciones aproximadas utiliza math.isclose():

import math

print(math.isclose(0.1 + 0.2, 0.3))

Operadores de asignación

contador = 10
contador += 1
contador -= 2
contador *= 3
contador /= 2

print(contador)

Las asignaciones aumentadas combinan una operación y una actualización. El comportamiento puede ser in-place para objetos mutables, por lo que debes considerar referencias compartidas.

Asignación múltiple

x, y = 10, 20
x, y = y, x

print(x, y)

Python desempaqueta los valores y permite intercambiar variables sin una variable temporal.

Operadores lógicos

edad = 22
tiene_documento = True
esta_bloqueado = False

puede_entrar = (
    edad >= 18
    and tiene_documento
    and not esta_bloqueado
)
print(puede_entrar)

• and necesita que ambas expresiones sean truthy.
• or necesita al menos una expresión truthy.
• not invierte el valor de verdad.

Cortocircuito

usuario = None

if usuario is not None and usuario.get("activo"):
    print("Usuario activo")

La segunda expresión no se evalúa si la primera es falsa. Esto evita llamar a get() sobre None.

and y or devuelven operandos

nombre = ""
nombre_visible = nombre or "Invitado"
print(nombre_visible)

or devuelve el primer operando truthy o el último evaluado. Este patrón puede reemplazar accidentalmente valores válidos como cero o una cadena vacía. Cuando la ausencia se representa con None, compárala explícitamente.

Operadores de pertenencia

lenguajes = ["Python", "JavaScript", "Go"]

print("Python" in lenguajes)
print("Rust" not in lenguajes)

En diccionarios, in comprueba claves:

usuario = {"nombre": "Ana", "activo": True}

print("nombre" in usuario)
print("Ana" in usuario.values())

La guía del operador in en Python compara strings, listas, sets, diccionarios y generadores.

Operadores de identidad

lista_a = [1, 2]
lista_b = [1, 2]
lista_c = lista_a

print(lista_a == lista_b)  # valores iguales
print(lista_a is lista_b)  # objetos distintos
print(lista_a is lista_c)  # mismo objeto

== compara valores. is compara identidad. Reserva is principalmente para objetos singleton como None.

Operadores bit a bit

a = 0b1100
b = 0b1010

print(bin(a & b))   # AND
print(bin(a | b))   # OR
print(bin(a ^ b))   # XOR
print(bin(~a))      # NOT
print(bin(a << 1))  # desplazamiento izquierda
print(bin(a >> 1))  # desplazamiento derecha

Estos operadores trabajan con representaciones binarias de enteros. Se utilizan en máscaras, protocolos, permisos y procesamiento de datos de bajo nivel. No los confundas con and y or, que operan sobre valores de verdad.

Operadores de conjuntos

a = {1, 2, 3, 4}
b = {3, 4, 5}

print(a | b)  # unión
print(a & b)  # intersección
print(a - b)  # diferencia
print(a ^ b)  # diferencia simétrica

Los mismos símbolos bit a bit tienen operaciones definidas para sets. La guía de sets en Python muestra subconjuntos, frozenset y casos prácticos.

Operador condicional

edad = 17
estado = "adulto" if edad >= 18 else "menor"
print(estado)

La expresión condicional es útil para una decisión breve. Cuando existen varias condiciones o efectos secundarios, un bloque if normal es más legible.

Operador walrus :=

while (texto := input("Mensaje: ").strip()) != "salir":
    print(f"Recibido: {texto}")

El operador de asignación permite asignar y utilizar un valor dentro de una expresión. Debe emplearse solamente cuando evita repetir una operación y mantiene la lectura clara.

Operadores con strings

saludo = "Hola, " + "Ana"
linea = "-" * 20

print(saludo)
print(linea)

El símbolo depende del tipo: + suma números, concatena strings y listas, mientras * repite secuencias cuando se combina con un entero.

Operadores con listas y mutabilidad

a = [1, 2]
b = a

a += [3]
print(a)
print(b)

En listas, += puede modificar el mismo objeto, por lo que b también observa el cambio. Con strings, que son inmutables, se crea un objeto nuevo.

Sobrecarga de operadores

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, otro):
        return Vector(self.x + otro.x, self.y + otro.y)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"


print(Vector(1, 2) + Vector(3, 4))

Los métodos especiales permiten definir operaciones para clases propias. Implementa solamente operadores cuyo significado sea natural y documentado. La guía de programación orientada a objetos en Python explica clases y métodos especiales.

Precedencia lógica

resultado = a or b and c
resultado_claro = a or (b and c)

and se evalúa antes que or. Utiliza paréntesis en condiciones mixtas para que el lector no dependa de memorizar la tabla de precedencia.

Funciones frente a operadores

import operator

numeros = [3, 1, 2]
usuarios = [
    {"nombre": "Ana", "edad": 28},
    {"nombre": "Luis", "edad": 22},
]

print(operator.add(2, 3))
ordenados = sorted(usuarios, key=operator.itemgetter("edad"))

El módulo operator es útil cuando una operación debe pasarse como función, por ejemplo a sorted(), map() o reduce().

Errores frecuentes

• Usar = cuando se necesita ==.
• Comparar valores con is.
• Confundir and con &.
• Esperar que / devuelva un entero.
• Ignorar el comportamiento de // con negativos.
• Comparar floats con igualdad exacta.
• Escribir condiciones largas sin paréntesis ni nombres intermedios.
• Usar or como valor predeterminado cuando cero es válido.
• Olvidar que += puede modificar objetos mutables.

Práctica recomendada

Prueba cada operador con distintos tipos y valores límite. Crea una calculadora, un sistema de permisos con sets, un validador de edades y una función que compare números con tolerancia. Convierte condiciones complejas en variables con nombres descriptivos y añade pruebas.

Conclusión

Los operadores en Python expresan cálculos, decisiones y relaciones entre datos. Su significado depende del tipo, por lo que no basta memorizar símbolos: debes comprender qué objetos reciben, qué resultado producen y si modifican el valor original.

Utiliza paréntesis para comunicar precedencia, == para valores, is para identidad y operadores lógicos para condiciones. Cuando una expresión se vuelva difícil de leer, divídela en pasos o funciones con nombres claros.