Operadores en Python

Los operadores son los símbolos que usas para calcular, comparar y combinar valores: +, ==, and, in… En esta lección los verás todos con ejemplos, junto con algunos detalles que suelen confundir al empezar: la diferencia entre / y //, qué devuelven realmente and y or, cuándo usar is y por qué 0.1 + 0.2 no da exactamente 0.3.

Operadores aritméticos

Operador	Operación	Ejemplo	Resultado
+	Suma	7 + 2	9
-	Resta	7 - 2	5
*	Multiplicación	7 * 2	14
/	División	7 / 2	3.5
//	División entera	7 // 2	3
%	Resto (módulo)	7 % 2	1
**	Potencia	2 ** 10	1024

/ siempre devuelve float

La división normal da un número decimal aunque el resultado sea exacto:

print(10 / 2)
print(type(10 / 2))
# 5.0
# <class 'float'>

Si quieres un entero, usa // o convierte con int().

// y %: división entera y resto

Son los operadores de “repartir”. Imagina que tienes 17 alumnos y grupos de 5:

alumnos = 17
por_grupo = 5
print(alumnos // por_grupo)   # 3 grupos completos
print(alumnos % por_grupo)    # 2 alumnos sobran

El resto % tiene usos muy habituales:

numero = 14
print(numero % 2 == 0)   # True: es par (el resto de dividir entre 2 es 0)
print(numero % 10)       # 4: la última cifra
print(125 % 60)          # 5: minutos que sobran tras las horas completas

Cuidado: con números negativos, // redondea hacia abajo (hacia menos infinito), no hacia cero. -7 // 2 da -4, no -3. Y -7 % 2 da 1, porque el resto toma el signo del divisor.

divmod: las dos cosas a la vez

divmod(a, b) devuelve el cociente y el resto juntos. Muy útil para convertir unidades:

segundos_totales = 3725
minutos, segundos = divmod(segundos_totales, 60)
horas, minutos = divmod(minutos, 60)
print(f"{horas} h {minutos} min {segundos} s")
# 1 h 2 min 5 s

**: potencias y raíces

print(2 ** 3)       # 8
print(9 ** 0.5)     # 3.0 (elevar a 0.5 es la raíz cuadrada)
print(10 ** -2)     # 0.01

Mezclar int y float

Si en una operación hay un float, el resultado es float: 3 + 2.0 da 5.0. Los int de Python no tienen límite: 2 ** 100 se calcula sin problema.

Asignación compuesta

Para actualizar una variable a partir de su propio valor hay atajos:

Atajo	Equivale a
x += 3	x = x + 3
x -= 3	x = x - 3
x *= 3	x = x * 3
x /= 3	x = x / 3
x //= 3	x = x // 3
x %= 3	x = x % 3
x **= 3	x = x ** 3

saldo = 100
saldo -= 30      # compra
saldo += 50      # ingreso
saldo *= 1.02    # intereses del 2 %
print(saldo)
# 122.4

Cuidado: en Python no existen ++ ni --. Para sumar uno escribe contador += 1. Curiosamente, ++contador no da error: Python lo interpreta como “más más contador”, que deja el número igual.

Operadores de comparación

Comparan dos valores y devuelven siempre un bool (True o False):

Operador	Significado	Ejemplo	Resultado
==	Igual	5 == 5	True
!=	Distinto	5 != 3	True
>	Mayor	5 > 3	True
<	Menor	5 < 3	False
>=	Mayor o igual	5 >= 5	True
<=	Menor o igual	4 <= 3	False

No confundas = (asignar) con == (comparar). También se comparan textos, por orden alfabético según los códigos de los caracteres, y las mayúsculas van antes que las minúsculas:

print("ana" < "luis")    # True
print("Zoe" < "ana")     # True: las mayúsculas van antes
print(3 == 3.0)          # True: mismo valor numérico
print("3" == 3)          # False: texto y número nunca son iguales

Python permite encadenar comparaciones como en matemáticas: 18 <= edad < 65 equivale a 18 <= edad and edad < 65. Lo verás en Condicionales.

Operadores lógicos: and, or y not

Combinan condiciones. Se escriben con palabras, no con símbolos como &&:

Operador	Devuelve verdadero si…
a and b	Las dos condiciones son verdaderas
a or b	Al menos una es verdadera
not a	a es falsa

edad = 20
tiene_entrada = False
print(edad >= 18 and tiene_entrada)   # False
print(edad >= 18 or tiene_entrada)    # True
print(not tiene_entrada)              # True

Evaluación en cortocircuito

Python deja de evaluar en cuanto conoce el resultado:

• En a and b, si a es falsa, ya no mira b.
• En a or b, si a es verdadera, ya no mira b.

Esto permite escribir comprobaciones seguras, como evitar una división entre cero:

total = 0
alumnos = 0
if alumnos > 0 and total / alumnos > 5:
    print("Buena media")
print("Sin error")
# Sin error

Como alumnos > 0 es False, nunca se llega a calcular total / alumnos.

and y or devuelven uno de los valores

Un detalle importante: and y or no devuelven necesariamente True o False, sino uno de los dos operandos. or devuelve el primero que sea truthy (o el último), y and el primero que sea falsy (o el último):

print("Ana" or "Invitado")   # Ana
print("" or "Invitado")      # Invitado
print(0 and 10)              # 0
print(5 and 10)              # 10

Se usa mucho or para dar un valor por defecto:

nombre = input("Nombre: ")   # el usuario pulsa Enter sin escribir
nombre = nombre or "Invitado"
print(f"Hola, {nombre}")
# Hola, Invitado

Operadores de pertenencia: in y not in

Comprueban si un valor está dentro de un texto o una colección:

print("py" in "python")               # True
print("rojo" in ["verde", "azul"])    # False
print("x" not in "casa")              # True
print("nombre" in {"nombre": "Ana"})  # True: en diccionarios busca en las claves

Identidad: is frente a ==

• == compara si dos valores son iguales.
• is comprueba si son el mismo objeto en memoria.

a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a == b)   # True: tienen el mismo contenido
print(a is b)   # False: son dos listas distintas
print(a is c)   # True: c y a son la misma lista

En la práctica, is solo se usa para comparar con None:

resultado = None
if resultado is None:
    print("Sin resultado todavía")
# Sin resultado todavía

Cuidado: no uses is para comparar números o textos. x is 5 puede funcionar a veces por casualidad (Python reutiliza algunos objetos pequeños), pero no está garantizado y el propio intérprete avisa con un SyntaxWarning. Para valores, usa siempre ==.

Precedencia de operadores

Cuando una expresión tiene varios operadores, Python sigue un orden, de mayor a menor prioridad:

Prioridad	Operadores
1 (más alta)	() paréntesis
2	**
3	-x (signo negativo)
4	*, /, //, %
5	+, -
6	==, !=, <, >, <=, >=, in, not in, is, is not
7	not
8	and
9 (más baja)	or

print(2 + 3 * 4)     # 14, no 20
print((2 + 3) * 4)   # 20
print(-2 ** 2)       # -4: primero la potencia, luego el signo
print(True or False and False)   # True: and va antes que or

Consejo: no memorices la tabla. Si una expresión no es evidente, pon paréntesis: no cambian el resultado y hacen que el código se lea mejor.

El operador morsa :=

Desde Python 3.8 existe :=, que asigna y devuelve el valor a la vez dentro de una expresión. Se llama “morsa” por su forma. Evita calcular algo dos veces:

texto = "aprender python"
if (longitud := len(texto)) > 10:
    print(f"Texto largo: {longitud} caracteres")
# Texto largo: 15 caracteres

Es útil, pero no abuses de él: una asignación normal en la línea anterior suele ser más clara.

Números decimales: round, abs y el problema de 0.1 + 0.2

El problema de la coma flotante

Prueba esto:

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
# 0.30000000000000004
# False

No es un error de Python: el ordenador guarda los float en binario, y números como 0.1 no tienen una representación exacta (igual que 1/3 no se puede escribir exacto en decimal: 0.3333…). Pasa en todos los lenguajes.

Soluciones:

import math

print(round(0.1 + 0.2, 2))              # 0.3
print(math.isclose(0.1 + 0.2, 0.3))     # True

Para dinero, donde cada céntimo importa, se usa el módulo decimal o se trabaja en céntimos con enteros.

round

round(numero, decimales) redondea. Sin segundo argumento devuelve un entero:

print(round(3.14159, 2))   # 3.14
print(round(7.6))          # 8
print(round(2.5))          # 2
print(round(3.5))          # 4

¿Por qué round(2.5) da 2? Python usa el redondeo del banquero: cuando el número está justo en la mitad, redondea al par más cercano. Así, al redondear muchos valores, los errores no se acumulan siempre hacia arriba. Si necesitas mostrar un número con decimales, mejor usa una f-string: f"{precio:.2f}".

abs

abs devuelve el valor absoluto (el número sin signo). Sirve, por ejemplo, para calcular diferencias:

temperatura_ayer = 18
temperatura_hoy = 11
print(abs(temperatura_hoy - temperatura_ayer))
# 7

Errores frecuentes

• Usar = en lugar de == en una condición: if edad = 18: da SyntaxError.
• Esperar un entero de /: 10 / 2 es 5.0. Si lo usas como índice de lista, falla.
• Escribir ++: contador++ es un SyntaxError. Usa contador += 1.
• Comparar float con ==: usa round o math.isclose.
• Usar is con números o textos: usa ==. Reserva is para None.
• Olvidar la precedencia: media = a + b / 2 divide solo b. Escribe (a + b) / 2.

Resumen

Grupo	Operadores	Recuerda
Aritméticos	+ - * / // % **	/ da float; // y % para repartir
Asignación	+= -= *= /= //= %= **=	No existe ++
Comparación	== != < > <= >=	Se pueden encadenar
Lógicos	and or not	Cortocircuito; devuelven un operando
Pertenencia	in, not in	En diccionarios mira las claves
Identidad	is, is not	Solo para is None
Morsa	:=	Asigna dentro de una expresión
Funciones	round, abs, divmod	round(2.5) es 2

Con los operadores dominados, el siguiente paso son las cadenas de texto y sus métodos.

print(divmod(125, 60))

print("" or "Invitado", 0 and 10)

print(round(2.5), round(3.5))

print(2 + 3 * 2 ** 2)