Operadores en Python: aritméticos, de comparación y lógicos
Actualizado el 29 de septiembre de 2026
Los operadores son los símbolos que hacen algo con los valores: sumarlos, compararlos o combinar condiciones. Los aritméticos se parecen a los de una calculadora, pero Python tiene algunos propios, como la división entera // y el resto %, que aparecen todo el tiempo en ejercicios de programación.
En esta guía vas a ver los tres grupos principales (aritméticos, de comparación y lógicos), en qué orden se evalúan y los errores que más se repiten al usarlos.
Operadores aritméticos
7 + 2 # 9 suma
7 - 2 # 5 resta
7 * 2 # 14 multiplicación
7 / 2 # 3.5 división (siempre devuelve float)
7 // 2 # 3 división entera
7 % 2 # 1 resto (módulo)
7 ** 2 # 49 potencia// y % van juntos: 7 // 2 es cuántas veces cabe el 2 en el 7, y 7 % 2 es lo que sobra. El resto sirve para muchas cosas: saber si un número es par (n % 2 == 0), si es múltiplo de otro o para quedarse con el último dígito (n % 10).
La división / siempre devuelve un float, aunque sea exacta: 6 / 2 es 3.0, no 3.
Orden de evaluación
Igual que en matemáticas, primero se evalúan las potencias, después multiplicaciones y divisiones, y al final sumas y restas. Los paréntesis cambian el orden, y conviene usarlos cuando hay dudas: hacen el código más fácil de leer.
2 + 3 * 4 # 14
(2 + 3) * 4 # 20
2 ** 3 ** 2 # 512 (la potencia se evalúa de derecha a izquierda: 2 ** 9)Operadores de comparación
Comparan dos valores y devuelven True o False:
x = 5
x == 5 # True igual
x != 5 # False distinto
x > 3 # True mayor
x <= 4 # False menor o igual
1 < x < 10 # True Python permite encadenar comparacionesLos textos también se pueden comparar: se ordenan como en un diccionario, pero las mayúsculas van antes que las minúsculas ("Z" < "a" es True). Para comparar textos sin importar mayúsculas, convierte ambos con .lower().
Operadores lógicos: and, or y not
Combinan condiciones. and es verdadero si ambas lo son, or si al menos una lo es, y not invierte el valor.
edad = 20
tiene_entrada = False
edad >= 18 and tiene_entrada # False: falta la entrada
edad >= 18 or tiene_entrada # True: basta con una
not tiene_entrada # TruePython evalúa de izquierda a derecha y se detiene apenas sabe el resultado: en a and b, si a es falso ya no mira b. Eso permite escribir cosas como lista and lista[0] > 0 sin que falle con una lista vacía.
Asignación abreviada y pertenencia
contador = 0
contador += 1 # igual que contador = contador + 1
contador *= 5 # contador vale 5
"py" in "python" # True
3 in [1, 2, 3] # True
4 not in [1, 2, 3] # TrueExisten +=, -=, *=, /=, //= y %=. El operador in pregunta si un valor está dentro de un texto o una colección, y se lee casi como español.
Errores comunes
Confundir = con ==
= asigna un valor y == compara. Escribir if x = 5: produce un SyntaxError. Si te pasa, Python suele sugerir en el mensaje que quisiste escribir ==.
Comparar contra varios valores con or
color = "verde"
color == "rojo" or "azul" # 'azul' → en un if, cuenta como verdadero
color in ("rojo", "azul") # False, que era lo que se quería saberor no reparte la comparación: color == "rojo" or "azul" se lee como (color == "rojo") or "azul", y un texto no vacío es verdadero. Escribe la comparación completa en cada lado (color == "rojo" or color == "azul") o usa in.
La división entera con negativos
// redondea hacia abajo, no hacia el cero: -7 // 2 es -4, no -3, y por la misma razón -7 % 2 es 1. Si trabajas con negativos y necesitas cortar los decimales, usa int(-7 / 2), que da -3.
Comparar decimales con ==
0.1 + 0.2 == 0.3 es False por cómo se guardan los float. Para comparar decimales, revisa si la diferencia es muy pequeña: abs((0.1 + 0.2) - 0.3) < 1e-9, o usa math.isclose().
Ejercicios resueltos
Intenta resolver cada ejercicio antes de abrir la solución: equivocarse y corregir es la parte que más enseña.
1.¿Es par?
Escribe una función es_par(n) que devuelva True si el entero n es par y False si no.
es_par(4)→Truees_par(7)→Falsees_par(0)→True
def es_par(n):
return ...Ver soluciónOcultar solución
def es_par(n):
return n % 2 == 0Un número es par si al dividirlo por 2 no sobra nada. La comparación ya es un True o False, así que se puede devolver directo, sin un if. Escribir if n % 2 == 0: return True else: return False funciona, pero es dar una vuelta innecesaria.
2.Año bisiesto
Escribe una función es_bisiesto(anio). Un año es bisiesto si es divisible por 4, excepto los divisibles por 100, que solo son bisiestos si además son divisibles por 400.
es_bisiesto(2024)→Truees_bisiesto(2023)→Falsees_bisiesto(1900)→Falsees_bisiesto(2000)→True
def es_bisiesto(anio):
return ...Ver soluciónOcultar solución
def es_bisiesto(anio):
return anio % 4 == 0 and (anio % 100 != 0 or anio % 400 == 0)La regla tiene dos partes que deben cumplirse a la vez: ser divisible por 4, y además no ser divisible por 100 o sí serlo por 400. Como and se evalúa antes que or, sin paréntesis la expresión se agruparía distinto. En este caso daría el mismo resultado (todo múltiplo de 400 también lo es de 4), pero no deberías tener que pensarlo: los paréntesis dejan la intención a la vista.
1900 es divisible por 4 y por 100, pero no por 400: no es bisiesto. 2000 es divisible por 400: sí lo es.
3.Convertir segundos a horas, minutos y segundos
Escribe una función convertir_segundos(total) que reciba una cantidad de segundos y devuelva cuántas horas, minutos y segundos son, en ese orden.
convertir_segundos(3725)→(1, 2, 5)convertir_segundos(59)→(0, 0, 59)
def convertir_segundos(total):
...Ver soluciónOcultar solución
def convertir_segundos(total):
horas = total // 3600
minutos = (total % 3600) // 60
segundos = total % 60
return horas, minutos, segundosUna hora son 3600 segundos, así que total // 3600 son las horas completas y total % 3600 los segundos que sobran. De esos, // 60 son los minutos. Los segundos finales son el resto de dividir el total por 60. Con 3725: 1 hora (3600), sobran 125, que son 2 minutos y 5 segundos.
return horas, minutos, segundos devuelve los tres valores juntos, como una tupla.