Si ya tienes claro lo de las variables y tipos de datos, el siguiente paso natural son los operadores en Python. Son las herramientas que te permiten hacer cálculos, comparar valores y tomar decisiones en tu código.

En este artículo vemos todos los tipos de operadores que necesitas conocer en primero, con los tres errores que más veces vi en clase explicados en detalle.

¿Qué son los operadores en Python?

Un operador es un símbolo que le dice a Python qué operación realizar con uno o más valores. Por ejemplo el + en 3 + 5 es un operador que le dice a Python que sume esos dos valores.

Python tiene varios tipos de operadores. Los veremos de más a menos usados.

Operadores aritméticos en Python — los del día a día

Son los que usarás en casi todos tus programas:

# Suma
print(5 + 3)    # → 8

# Resta
print(5 - 3)    # → 2

# Multiplicación
print(5 * 3)    # → 15

# División normal
print(5 / 2)    # → 2.5  (siempre devuelve float)

# División entera
print(5 // 2)   # → 2    (redondea hacia abajo)

# Módulo (resto de la división)
print(5 % 2)    # → 1

# Potencia
print(5 ** 2)   # → 25

Error clásico 1 — confundir / con //

Este es el error que más veces vi en los ejercicios de FP1. La división normal / en Python siempre devuelve un número decimal (float), aunque el resultado sea exacto:

print(10 / 2)   # → 5.0  NO es 5, es 5.0
print(10 // 2)  # → 5    esto sí es entero

¿Cuándo usar cada una? Usa / cuando necesites decimales, como calcular medias o porcentajes. Usa // cuando necesites un entero exacto, como contar cuántas filas caben en una pantalla o dividir personas en grupos iguales.

Error clásico 2 — el operador % no es porcentaje

Cuando ves % en Python no significa porcentaje, significa módulo, es decir el resto de una división entera. Es uno de los operadores más útiles pero también el más confuso al principio:

print(10 % 3)   # → 1   porque 10 = 3×3 + 1
print(15 % 5)   # → 0   porque 15 = 5×3 + 0
print(7 % 2)    # → 1   porque 7 = 2×3 + 1

¿Para qué sirve en la práctica? Para saber si un número es par o impar:

numero = 7
if numero % 2 == 0:
    print("Es par")
else:
    print("Es impar")

Si el resto de dividir entre 2 es 0, el número es par. Si es 1, es impar. Lo verás en muchísimos ejercicios de FP1.

También sirve para saber si un número es divisible por otro:

print(15 % 3)   # → 0  15 es divisible por 3
print(16 % 3)   # → 1  16 no es divisible por 3

Operadores de comparación — devuelven True o False

Estos operadores comparan dos valores y devuelven un booleano — True si la comparación es cierta, False si no:

print(5 > 3)    # → True
print(5 < 3)    # → False
print(5 >= 5)   # → True
print(5 <= 4)   # → False
print(5 == 5)   # → True   (igual)
print(5 != 3)   # → True   (distinto)

Error clásico 3 — confundir = con ==

Este es probablemente el error más frecuente en primero y el que más tiempo hace perder buscando el fallo:

# = es asignación — guarda un valor en una variable
x = 5           # x ahora vale 5

# == es comparación — comprueba si dos valores son iguales
print(x == 5)   # → True
print(x == 3)   # → False

El problema típico es usar = cuando querías comparar:

# MAL — esto da error de sintaxis en Python
if x = 5:
    print("Es cinco")

# BIEN
if x == 5:
    print("Es cinco")

Python da un error de sintaxis si intentas usar = dentro de un if, así que este error al menos se detecta rápido. Pero en otros contextos puede pasar desapercibido, así que acostúmbrate a usar siempre == para comparar.

Operadores lógicos — combinar condiciones

Cuando necesitas comprobar varias condiciones a la vez usas los operadores lógicos:

# and — ambas condiciones deben ser True
edad = 20
tiene_dni = True
print(edad >= 18 and tiene_dni)   # → True

# or — al menos una condición debe ser True
es_estudiante = True
tiene_descuento = False
print(es_estudiante or tiene_descuento)   # → True

# not — invierte el valor booleano
aprobado = False
print(not aprobado)   # → True

En la práctica los usarás constantemente en los if de tus programas:

nota = 6.5
asistencia = 80

if nota >= 5 and asistencia >= 75:
    print("Aprobado")
else:
    print("Suspenso")

Operadores de asignación compuesta — el atajo que ahorra tiempo

Python tiene una versión compacta de los operadores aritméticos combinados con la asignación. Son muy útiles en bucles:

x = 10

x += 5    # equivale a x = x + 5  → x ahora vale 15
x -= 3    # equivale a x = x - 3  → x ahora vale 12
x *= 2    # equivale a x = x * 2  → x ahora vale 24
x /= 4    # equivale a x = x / 4  → x ahora vale 6.0
x //= 2   # equivale a x = x // 2 → x ahora vale 3.0
x **= 2   # equivale a x = x ** 2 → x ahora vale 9.0
x %= 4    # equivale a x = x % 4  → x ahora vale 1.0

El más usado con diferencia es += — lo verás en todos los acumuladores y contadores de FP1.

Precedencia de operadores — el orden importa

Python sigue un orden de prioridad para evaluar las operaciones, igual que en matemáticas. De mayor a menor prioridad:

# 1. Paréntesis        ( )
# 2. Potencia          **
# 3. Multiplicación, división, módulo   * / // %
# 4. Suma y resta      + -
# 5. Comparación       > < >= <= == !=
# 6. not
# 7. and
# 8. or

En la práctica esto significa que estas dos expresiones dan resultados diferentes:

print(2 + 3 * 4)      # → 14  (primero 3*4=12, luego 2+12)
print((2 + 3) * 4)    # → 20  (primero 2+3=5, luego 5*4)

La regla de oro: cuando tengas dudas, usa paréntesis. Hacen el código más legible y evitan errores de precedencia. Es mejor poner un paréntesis de más que uno de menos.

Visualízalo con Python Tutor

Para entender cómo Python evalúa una expresión paso a paso, copia esto en pythontutor.com y ejecútalo línea por línea:

a = 10
b = 3

suma = a + b
resta = a - b
division = a / b
division_entera = a // b
modulo = a % b
potencia = a ** b

print(suma, resta, division, division_entera, modulo, potencia)

Verás cómo Python crea cada variable con su valor en memoria. Especialmente útil para ver la diferencia entre / y //.

Resumen rápido

Los operadores en Python se dividen en aritméticos, comparación, lógicos y de asignación compuesta.

• + - * / // % ** — operadores aritméticos
• / siempre devuelve float — usa // para división entera
• % es el resto de la división — no es porcentaje
• = asigna, == compara — no los confundas
• and or not — operadores lógicos para combinar condiciones
• += -= *= — atajos de asignación compuesta
• Cuando dudes del orden de evaluación — usa paréntesis

En el próximo artículo practicamos todos estos operadores con programas reales en VS Code.

---

Python operators — complete guide with the mistakes everyone makes

If you’re comfortable with variables and data types, the next step is Python operators, the tools that let you calculate, compare values, and make decisions in your code. Here’s everything you need for first year, including the three mistakes I saw most often in class.

What is an operator?

A symbol that tells Python what operation to perform. The + in 3 + 5 is an operator that tells Python to add those values.

Arithmetic operators

print(5 + 3)    # → 8   addition
print(5 - 3)    # → 2   subtraction
print(5 * 3)    # → 15  multiplication
print(5 / 2)    # → 2.5 division (always float)
print(5 // 2)   # → 2   floor division (integer)
print(5 % 2)    # → 1   modulo (remainder)
print(5 ** 2)   # → 25  power

Classic mistake 1 — confusing / with //

print(10 / 2)   # → 5.0  float, not integer
print(10 // 2)  # → 5    integer

Use / when you need decimals. Use // when you need a whole number.

Classic mistake 2 — % is not percentage

% means modulo, the remainder of integer division:

print(10 % 3)   # → 1
print(15 % 5)   # → 0

Most common use, checking if a number is even or odd:

number = 7
if number % 2 == 0:
    print("Even")
else:
    print("Odd")

Comparison operators — return True or False

print(5 > 3)    # → True
print(5 < 3)    # → False
print(5 == 5)   # → True
print(5 != 3)   # → True

Classic mistake 3 — confusing = with ==

x = 5           # assignment — stores a value
print(x == 5)   # comparison — checks equality

Using = inside an if causes a syntax error in Python, so at least this mistake is caught quickly. But always use == to compare, = to assign.

Logical operators

# and — both conditions must be True
print(age >= 18 and has_id)

# or — at least one must be True
print(is_student or has_discount)

# not — inverts the boolean
print(not passed)

Compound assignment operators

x = 10
x += 5    # x = x + 5  → 15
x -= 3    # x = x - 3  → 12
x *= 2    # x = x * 2  → 24
x /= 4    # x = x / 4  → 6.0

+= is the most common, you’ll see it in every accumulator and counter in FP1.

Operator precedence

# Priority (high to low):
# 1. Parentheses  ( )
# 2. Power        **
# 3. * / // %
# 4. + -
# 5. > < >= <= == !=
# 6. not
# 7. and
# 8. or

print(2 + 3 * 4)      # → 14  (3*4 first)
print((2 + 3) * 4)    # → 20  (2+3 first)

Golden rule: when in doubt, use parentheses.

Visualise it with Python Tutor

a = 10
b = 3

division = a / b
floor_div = a // b
modulo = a % b

print(division, floor_div, modulo)

Paste this into pythontutor.com and step through it to see how Python evaluates each operation.

Quick summary

• / always returns float — use // for integer division
• % is remainder — not percentage
• = assigns, == compares — never mix them up
• Use parentheses when precedence is unclear

Next up: practising all these operators with real programs in VS Code.