Operadores de Python: aritmética, división // y %, comparación, and/or/not y round en Python

Los operadores de Python son símbolos que combinan valores y producen un nuevo valor: + suma, // divide sin resto y and combina condiciones. A continuación tiene la lista completa de operadores con ejemplos, la diferencia entre / y //, la lógica de and, or y not, y las funciones de redondeo: round en Python, math.ceil, math.floor y abs. Todos los ejemplos se pueden pegar en el REPL y comprobar.

Lista de operadores de Python

Los operadores se agrupan por su función. No hace falta memorizar la tabla completa: en el código real lo que más aparece son la aritmética, la comparación y los operadores lógicos.

Operadores aritméticos

La suma, la resta y la multiplicación funcionan como en la escuela. Si en una expresión interviene al menos un float, el resultado también será float: 2 + 1.0 da 3.0. Los enteros en Python no desbordan: 2 ** 100 se calcula con exactitud, sin importar cuántas cifras tenga.

>>> 250 + 120
370
>>> 12.5 * 3
37.5
>>> 2 ** 10
1024
>>> 2 ** 0.5
1.4142135623730951

Potencia en Python: el operador **

La potencia se escribe con dos asteriscos, no con ^: en Python el signo ^ significa «O exclusivo» bit a bit, y 2 ^ 3 devuelve 1, no 8. Una potencia fraccionaria da una raíz: 9 ** 0.5 es 3.0. Existe también la función pow(x, y), que hace lo mismo y admite un tercer argumento para el resto: pow(2, 10, 1000) devuelve 24.

Ojo con la prioridad: ** se ejecuta antes que el menos unario, así que -2 ** 2 da -4. Para elevar al cuadrado un número negativo, escriba los paréntesis: (-2) ** 2.

División en Python: /, // y %

En Python hay dos tipos de división, y esa es la principal fuente de sorpresas para los principiantes. La división normal / siempre devuelve un float, incluso si la división es exacta. La división entera // descarta la parte decimal, y %, el operador módulo (modulo operator en inglés), devuelve el resto.

>>> 7 / 2
3.5
>>> 8 / 2
4.0
>>> 7 // 2
3
>>> 7 % 2
1

División entera // y resto %: en la práctica

El par // y % resuelve los problemas del tipo «cuántos enteros salen y cuánto sobra». En el curso, el registro de gastos guarda el dinero en centavos para no perder precisión y separa el importe en unidades y centavos:

centavos = 125050         # guardamos el dinero en centavos
pesos = centavos // 100   # 1250 — pesos enteros
cent = centavos % 100     # 50 — el resto
print(pesos, cent)        # 1250 50

print(40 // 7, "semanas y", 40 % 7, "días")   # 5 semanas y 5 días

Ambas operaciones a la vez las devuelve la función integrada divmod: divmod(125050, 100) da la tupla (1250, 50). El resto también sirve para comprobar la paridad: n % 2 == 0 es verdadero para los números pares.

Números negativos: // redondea hacia abajo

El operador // no se limita a descartar la fracción: redondea hacia abajo, hacia menos infinito. Con números positivos no hay diferencia; con negativos, sí. El signo del resto % en Python coincide con el signo del divisor, de modo que siempre se cumple a == (a // b) * b + a % b.

>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # descarta la fracción, no redondea hacia abajo
-3

División entre cero: qué error aparece

Dividir entre cero con cualquiera de los tres operadores provoca la excepción ZeroDivisionError. Esto ocurre tanto con enteros como con decimales. Se puede capturar con try/except o comprobar el divisor de antemano.

>>> 10 / 0
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> contador = 0
>>> promedio = 1500 / contador if contador else 0
>>> promedio
0

Operadores de comparación

Las comparaciones devuelven True o False. La igualdad se comprueba con dos signos ==; un solo = es una asignación. Las cadenas se comparan carácter a carácter por sus códigos, así que "B" < "a" es verdadero: las mayúsculas van antes que las minúsculas.

>>> 250 == 250.0
True
>>> 3 != 4
True
>>> 1 < 5 <= 10     # cadena: 1 < 5 and 5 <= 10
True
>>> 0.1 + 0.2 == 0.3
False

Las cadenas de comparaciones como 0 <= x < 100 son una comodidad de Python: no hace falta escribir and. La última línea recuerda el error de precisión de los decimales: 0.1 + 0.2 da 0.30000000000000004. Para comparar decimales use math.isclose(a, b) y guarde el dinero en centavos o en Decimal.

Operadores lógicos and, or, not

Los operadores lógicos en Python se escriben con palabras, no con los símbolos && y || de otros lenguajes. and es verdadero cuando lo son ambas partes, or cuando lo es al menos una, y not invierte el valor.

Prioridad: primero not, luego and y después or. La expresión True or False and False es True, porque and se evalúa primero. En condiciones complejas use paréntesis: el código se entiende mejor, para usted y para sus compañeros.

Qué devuelven realmente and y or

and y or no devuelven necesariamente True o False, sino uno de los operandos. or devuelve el primer valor verdadero (o el último, si no hay ninguno), y and el primer valor falso (o el último). Son falsos 0, 0.0, la cadena vacía, las colecciones vacías, None y False.

>>> nombre = ""
>>> nombre or "Invitado"
'Invitado'
>>> 5 and 0
0
>>> not ""
True

La evaluación es perezosa: si el resultado ya está claro por la parte izquierda, la derecha no se calcula. Por eso contador and total / contador no falla con división entre cero cuando contador == 0. El operador not, a diferencia de los otros dos, siempre devuelve un bool.

Operadores is e in

== compara valores, mientras que is comprueba que dos nombres apuntan al mismo objeto. Dos listas distintas con el mismo contenido son iguales, pero no son el mismo objeto. El único lugar donde is se necesita siempre es la comprobación de None: if x is None.

>>> a = [250, 120]
>>> b = [250, 120]
>>> a == b, a is b
(True, False)
>>> c = a
>>> c is a
True

No compare números ni cadenas con is: a veces «funciona» por el caché interno de objetos, pero el resultado depende de la implementación, y Python muestra SyntaxWarning en construcciones como x is 5.

El operador in comprueba la pertenencia: una subcadena dentro de una cadena, un elemento de una lista, una clave de un diccionario. not in es la comprobación contraria.

>>> "café" in "café con leche"
True
>>> "comida" in {"comida": 450, "taxi": 300}
True
>>> 5 not in [1, 2, 3]
True

Operadores de asignación y el operador morsa :=

Los operadores compuestos +=, -=, *=, //= y otros son una abreviatura: total += 250 equivale a total = total + 250. En Python no existen los operadores ++ y --: escribir x++ provoca un error de sintaxis.

El operador morsa := (llamado así por su parecido con los ojos y los colmillos de la morsa) asigna un valor dentro de una expresión. Resulta útil cuando el valor hace falta a la vez para comprobar y para usar después:

gastos = ["café", "taxi", "comida", "cine"]
if (n := len(gastos)) > 3:
    print(f"Demasiados gastos: {n}")

while (linea := input("Importe: ")) != "":
    print(int(linea) * 2)

Sin la morsa habría que llamar a len dos veces o sacar la asignación a una línea aparte. Abusar de ella no conviene: si la línea se vuelve ilegible, es mejor una asignación normal.

Redondeo en Python: round, ceil, floor

Para redondear en Python existe la función integrada round y las funciones del módulo math. Resuelven tareas distintas, y confundirlas es un error frecuente.

La función round en Python y el redondeo bancario

La función round(x, n) redondea a n decimales; sin segundo argumento devuelve un int. La trampa principal: round en Python redondea el «medio» al par más cercano, al estilo bancario. Por eso round(2.5) da 2 y round(3.5) da 4. Así los errores de redondeo no se acumulan en una sola dirección en cálculos grandes.

>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # a las centenas
1200
>>> round(2.675, 2)     # no 2.68: en binario es 2.67499...
2.67

Si necesita el redondeo escolar «la mitad hacia arriba», por ejemplo en un recibo, use Decimal con el modo ROUND_HALF_UP. Pase el número como cadena para no heredar el error del float:

>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.5").quantize(Decimal("1"), ROUND_HALF_UP)
Decimal('3')
>>> Decimal("2.675").quantize(Decimal("0.01"), ROUND_HALF_UP)
Decimal('2.68')

Y otra regla del curso: redondee solo al mostrar. Para imprimir bonito no hace falta round: basta una f-string, f"{importe:.2f}" muestra dos decimales y el número en sí sigue siendo exacto.

math.ceil y math.floor: redondeo hacia arriba y hacia abajo

math.ceil sirve cuando «faltar» no es aceptable: cuántos autobuses contratar, cuántas páginas hacen falta en los resultados. math.floor sirve cuando solo cuentan las unidades completas. Ambas funciones devuelven un int.

import math

invitados = 47
asientos = 20
print(math.ceil(invitados / asientos))   # 3 autobuses
print(math.floor(9.99))                  # 9
print(-(-invitados // asientos))         # 3 — ceil sin math, con //

En el módulo math hay más funciones útiles: math.sqrt (raíz), math.isclose (comparación de decimales), math.pi, math.gcd. En Python 3.15 apareció el submódulo math.integer (PEP 791) para matemática entera: en él están comb, factorial, gcd, isqrt, lcm, perm, y las funciones antiguas como math.gcd siguen funcionando.

Función abs: valor absoluto

abs(x) devuelve el módulo, es decir, la distancia a cero sin signo. No requiere importar nada, la función es integrada. Funciona con enteros, decimales e incluso complejos: para 3+4j devuelve la longitud del vector, 5.0.

>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> presupuesto, gastado = 5000, 5320
>>> abs(presupuesto - gastado)    # cuánto nos desviamos
320

El uso típico es la diferencia sin tener en cuenta el sentido, y la comparación con una tolerancia: abs(a - b) < 0.001. Para decimales es más fiable math.isclose, porque tiene en cuenta la escala de los números.

Prioridad de los operadores

Cuando una expresión tiene varios operadores, Python los ejecuta por prioridad, de mayor a menor:

1. **
2. unarios -x, +x, ~x
3. * / // %
4. + -
5. desplazamientos y operaciones bit a bit
6. comparaciones, in, is
7. not
8. and
9. or
10. :=

Así, 2 + 3 * 4 es 14, y (2 + 3) * 4 es 20. Si tiene dudas, ponga paréntesis: los paréntesis de más no cuestan nada, mientras que un error de prioridad tarda mucho en encontrarse.

Errores frecuentes con los operadores

Conclusión

Lo más importante: / siempre da float, // redondea hacia abajo, % devuelve el resto con el signo del divisor, y la potencia es **. Los operadores lógicos and, or y not se escriben con palabras y se evalúan de forma perezosa, y is sirve para comprobar None. La función round en Python redondea al par; para redondear hacia arriba y hacia abajo están math.ceil y math.floor, y el valor absoluto lo da abs. En el curso estos operadores se practican en un caso real, el registro de gastos, donde el dinero se guarda en centavos.