Operador módulo en Python: conceptos clave

El operador módulo (%) en Python es un operador aritmético fundamental que sirve para obtener el resto de una división. Aunque su concepto es sencillo, tiene un papel clave en muchas aplicaciones de programación. Desde comprobar si un número es par o impar hasta recorrer secuencias de forma cíclica o determinar años bisiestos, dominar el operador módulo mejora tu capacidad para resolver problemas en Python.

Entender el operador módulo es esencial porque aparece con frecuencia en:

• Identificar números pares e impares
• Recorrer elementos de forma cíclica
• Implementar cálculos matemáticos con aritmética modular
• Aplicaciones prácticas como cálculos de fechas, criptografía y lógica de juegos.

En este blog encontrarás una guía completa para usar el operador módulo en Python: sintaxis, comportamiento con distintos tipos numéricos, casos de uso y ejemplos prácticos. Si estás empezando con Python, te recomendamos nuestro curso Introduction to Python.

¿Qué es el operador módulo en Python?

El operador módulo (%) calcula el resto de la división entre dos números. Dados dos números, a (dividendo) y b (divisor), la operación módulo devuelve el resto cuando a se divide entre b.

Fundamento matemático

El módulo tiene su base en la aritmética modular, un sistema aritmético para enteros en el que los números "vuelven a empezar" al alcanzar un determinado valor (módulo). Se utiliza ampliamente en criptografía, hashing y cálculos cíclicos.

Piensa en un reloj de 12 horas: después de las 12, en lugar de seguir a 13, se vuelve a 1. Esto es, esencialmente, aritmética modular con módulo 12:

• 13 % 12 = 1, es decir, las 13 horas corresponden a la 1 en formato de 12 horas.

Sintaxis del módulo en Python y uso básico

En Python, la sintaxis del operador módulo es directa:

remainder = dividend % divisor

Veamos algunos ejemplos básicos:

# Operaciones básicas con módulo
print(7 % 3)     
print(15 % 4)   
print(20 % 5)  

1 
3 
0 

Al dividir 7 entre 3, obtenemos 2 con un resto de 1. El operador módulo devuelve ese resto. Del mismo modo, 15 dividido entre 4 da 3 con resto 3, y 20 entre 5 da exactamente 4 sin resto.

Trabajar con enteros

Ahora que ya entendemos lo básico, veamos cómo se comporta el operador módulo con enteros.

Módulo con enteros positivos

Trabajar con enteros positivos es el caso más sencillo para el operador módulo:

# Ejemplos con enteros positivos
print(10 % 3)      
print(25 % 7)     
print(100 % 10)  

1 
4 
0 

En estos ejemplos, calculamos cuántas veces cabe el divisor en el dividendo y qué sobra:

• 10 ÷ 3 = 3, resto 1; por tanto, 10 % 3 = 1
• 25 ÷ 7 = 3, resto 4; por tanto, 25 % 7 = 4
• 100 ÷ 10 = 10, resto 0; por tanto, 100 % 10 = 0

Módulo con enteros negativos

El comportamiento del operador módulo se vuelve más interesante con números negativos. Python sigue una regla específica: el resultado de a % b siempre tiene el mismo signo que b (el divisor).

# Ejemplos con enteros negativos
print(-10 % 3)    
print(10 % -3)    
print(-10 % -3) 

2 
-2 
-1 

Estos resultados pueden parecer contraintuitivos al principio, pero siguen una regla coherente:

1. Para -10 % 3: En lugar de -1 (que podría esperarse si piensas en -10 ÷ 3 = -3, resto -1), Python devuelve 2. Es porque Python busca un valor entre 0 y 3 (excluido) que, sumado a un múltiplo de 3, dé -10. La respuesta es 2, ya que -12 + 2 = -10.
2. Para 10 % -3: El resultado tiene el mismo signo que el divisor (-3), así que obtenemos -2. Porque 10 = (-3) × (-4) + (-2).
3. Para -10 % -3: El resultado es -1, ya que -10 = (-3) × 3 + (-1).

Comprender cómo maneja Python los números negativos en el módulo es crucial en cálculos cíclicos, como:

• Implementar funciones de hashing
• Resolver problemas de aritmética de reloj
• Gestionar lógica de indexación negativa en listas

Uso del módulo con números de coma flotante

El operador módulo de Python no se limita a enteros; también funciona con números de coma flotante:

# Módulo con números de coma flotante
print(7.5 % 2)     
print(9.7 % 4.2)  
print(5.0 % 0.2)  

1.5
1.299999999999999
0.19999999999999973

Con números en coma flotante, la operación módulo sigue el mismo principio: devuelve el resto tras la división. Sin embargo, por la forma en que se almacenan los flotantes en los ordenadores (formato IEEE 754), pueden aparecer pequeños errores de redondeo.

Por ejemplo, en lugar de 1.3, Python devuelve 1.299999999999999, y en lugar de 0.2, devuelve 0.19999999999999973. Estas pequeñas imprecisiones son habituales en la aritmética de coma flotante y hay que tenerlas en cuenta en cálculos muy precisos.

Python también ofrece la función math.fmod() del módulo math como alternativa para operaciones de módulo con flotantes, que puede manejar ciertos casos límite de forma diferente:

import math

print(math.fmod(7.5, 2))    
print(math.fmod(-7.5, 2))  

# Comparación con el operador módulo de Python 
print(-7.5 % 2) 

1.5
-1.5
0.5

La principal diferencia entre % y math.fmod() está en cómo tratan los números negativos. Mientras que % garantiza que el resultado tenga el mismo signo que el divisor y devuelve un valor en el rango [0, divisor), math.fmod() hace que el resultado tenga el mismo signo que el dividendo. Esta distinción es importante cuando el signo del resto importa.

Entonces, ¿cuándo usar % y cuándo math.fmod()?

• Usa % cuando necesites un comportamiento de signo coherente (p. ej., al recorrer un rango).
• Usa math.fmod() cuando deba preservarse el signo del dividendo, como en simulaciones físicas o funciones matemáticas.

Cómo manejar números negativos con el módulo en Python

Como hemos visto, la implementación de Python con números negativos puede no coincidir con la intuición inicial. Veamos este comportamiento de forma más sistemática:

# Entender el patrón con números negativos
for i in range(-10, 11):
    result = i % 3
    print(f"{i} % 3 = {result}")

-10 % 3 = 2
-9 % 3 = 0
-8 % 3 = 1
-7 % 3 = 2
-6 % 3 = 0
-5 % 3 = 1
-4 % 3 = 2
-3 % 3 = 0
-2 % 3 = 1
-1 % 3 = 2
0 % 3 = 0
1 % 3 = 1
2 % 3 = 2
3 % 3 = 0
4 % 3 = 1
5 % 3 = 2
6 % 3 = 0
7 % 3 = 1
8 % 3 = 2
9 % 3 = 0
10 % 3 = 1

Fíjate en el patrón: los resultados se repiten 0 → 1 → 2 una y otra vez, tanto si el dividendo es positivo como negativo. Esta coherencia hace que el operador módulo sea especialmente útil en cálculos cíclicos, como:

• Rotar índices en arrays o buffers circulares
• Mapear valores en funciones periódicas (p. ej., cálculos basados en tiempo)

La fórmula matemática que sigue Python para el módulo es:

Import math 

a % b = a - (b * math.floor(a / b))

Esto garantiza que el resultado esté siempre entre 0 y b (excluido) cuando b es positivo, o entre b y 0 (excluido) cuando b es negativo.

Resumen del operador módulo en Python

El operador módulo (%) en Python calcula el resto de una división. Sigue una fórmula matemática consistente:

a % b = a - (b * math.floor(a / b))

Reglas clave del comportamiento del módulo en Python:

1. Para divisores positivos (b > 0)
• El resultado siempre está en el rango [0, b) (incluye 0 y excluye b).
2. Para divisores negativos (b < 0)
• El resultado siempre está en el rango (b, 0] (excluye b e incluye 0).
• El resto adopta el mismo signo que b (el divisor).
3. Funciona con enteros y con flotantes
• Con números de coma flotante, % sigue la misma fórmula, pero puede introducir pequeños errores de redondeo por la precisión de los flotantes.
4. Diferencias entre % y math.fmod()
• % garantiza que el resto tenga el mismo signo que el divisor.
• math.fmod(a, b) garantiza que el resto tenga el mismo signo que el dividendo.

Casos de uso habituales del operador módulo

Veamos aplicaciones prácticas del operador módulo con más ejemplos.

Comprobar si un número es par o impar

Una de las aplicaciones más comunes del módulo es determinar si un número es par o impar:

def is_even(number):
    return number % 2 == 0

def is_odd(number):
    return number % 2 != 0

# Probar las funciones
numbers = [1, 2, -3, 4, -5, 6, 7]
for num in numbers:
    if is_even(num):
        print(f"{num} is even")
    else:
        print(f"{num} is odd")

1 is odd
2 is even
-3 is odd
4 is even
-5 is odd
6 is even
7 is odd

Funciona porque los números pares dejan un resto de 0 al dividirse entre 2, mientras que los impares dejan un resto de 1 o -1.

Recorrer una secuencia de forma cíclica

El operador módulo es perfecto para crear comportamientos cíclicos, como rotar por una lista de elementos:

days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]

def get_day(n):
    # Devuelve el día de la semana para el día n, donde el día 0 es Monday
    return days[n % len(days)]

# Empezando en Monday (día 0), ¿qué día será dentro de 10 días?
print(get_day(10))  # Output: "Thursday"

# ¿Qué día fue hace 15 días desde Monday?
print(get_day(-15))  # Output: "Sunday"

Thursday
Sunday

En este ejemplo, por grande o pequeño (negativo) que sea n, la función siempre devolverá un día válido de la semana.

Cálculo de años bisiestos

Aunque el cálculo de años bisiestos implica varias condiciones, el operador módulo es central en el algoritmo:

Las reglas son:

• Un año es bisiesto si es divisible por 4.
• Pero si es divisible por 100, no es bisiesto.
• A menos que también sea divisible por 400; en ese caso, sí es bisiesto.

def is_leap_year(year):

    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)

# Probar la función
years = [1900, 2000, 2004, 2020, 2023, 2024]
for year in years:
    if is_leap_year(year):
        print(f"{year} is a leap year")
    else:
        print(f"{year} is not a leap year")

1900 is not a leap year
2000 is a leap year
2004 is a leap year
2020 is a leap year
2023 is not a leap year
2024 is a leap year

Así nos aseguramos de aplicar correctamente las reglas del calendario gregoriano.

Ejemplos prácticos del módulo en Python

Aquí tienes algunas formas de usar el operador módulo en tus propios proyectos en Python:

Usar módulo en bucles

El operador módulo se usa a menudo en bucles para ejecutar acciones a intervalos regulares:

# Imprime un mensaje cada 5 iteraciones
for i in range(1, 11):
    print(f"Processing item {i}", end=": ")
    if i % 5 == 0:
        print("Checkpoint reached!")
    else:
        print("Continuing...")

Processing item 1: Continuing...
Processing item 2: Continuing...
Processing item 3: Continuing...
Processing item 4: Continuing...
Processing item 5: Checkpoint reached!
Processing item 6: Continuing...
Processing item 7: Continuing...
Processing item 8: Continuing...
Processing item 9: Continuing...
Processing item 10: Checkpoint reached!

Este patrón es útil para procesar en lotes, informar del progreso o implementar cualquier funcionalidad periódica.

Módulo en aplicaciones reales

Hashing de contraseñas

En criptografía, la aritmética modular es fundamental. Este es un ejemplo simplificado de cómo podría usarse en una función de hashing básica:

def simple_hash(text, modulus=1000000007):
    """A very simple hash function using modulo."""
    hash_value = 0
    for char in text:
        # Combina el hash actual con el código Unicode del carácter
        hash_value = (hash_value * 31 + ord(char)) % modulus
    return hash_value

# Pruebas con algunas cadenas
print(simple_hash("hello"))  # Devuelve un número entre 0 y 1000000006
print(simple_hash("world"))
print(simple_hash("hello world"))
print(simple_hash("こんにちは"))  

99162322
113318802
204910434
807637228

Este es un ejemplo muy básico; el hashing criptográfico real es mucho más complejo. La operación módulo mantiene el valor del hash dentro de un rango manejable y ayuda a conservar buenas propiedades de dispersión.

Cálculo de horas en reloj

El módulo es útil para manejar cálculos de tiempo, como convertir muchas horas en formatos estándar.

def convert_to_12_hour_format(hours):
    return hours % 12 or 12  # Asegura que 0 se mapea a 12

# Ejemplo
print(convert_to_12_hour_format(13))  # Output: 1
print(convert_to_12_hour_format(24))  # Output: 12
print(convert_to_12_hour_format(36))  # Output: 12

Aquí, el operador módulo hace que las horas "den la vuelta" en un formato de 12 horas.

Desarrollo de juegos: sistema de turnos multijugador

En juegos por turnos multijugador, podemos usar el módulo para alternar entre jugadores.

players = ["Alice", "Bob", "Charlie"]
turns = 10

for turn in range(turns):
      current_player = players[turn % len(players)]
      print(f"Turn {turn + 1}: {current_player}'s move")

Turn 1: Alice's move
Turn 2: Bob's move
Turn 3: Charlie's move
Turn 4: Alice's move
Turn 5: Bob's move
Turn 6: Charlie's move
Turn 7: Alice's move
Turn 8: Bob's move
Turn 9: Charlie's move
Turn 10: Alice's move

Validación de dígitos en códigos de barras

Muchos sistemas de códigos de barras usan operaciones de módulo para detectar errores en números escaneados.

def is_valid_isbn13(isbn):
    digits = [int(d) for d in str(isbn)]
    checksum = sum(d * (1 if i % 2 == 0 else 3) for i, d in enumerate(digits))
    return checksum % 10 == 0

# Ejemplos de validación de ISBN
print(is_valid_isbn13(9780306406157))  # Output: True
print(is_valid_isbn13(9780306406158))  # Output: False

True
False

Conclusión

El operador módulo es una herramienta versátil en el ecosistema de Python que va mucho más allá de calcular restos. Desde determinar pares/impares hasta implementar algoritmos con patrones cíclicos, el módulo permite soluciones más limpias y elegantes a numerosos retos de programación.

Si comprendes tanto su funcionamiento básico como sus matices con diferentes tipos numéricos, podrás aprovecharlo para escribir código más eficiente y legible. La próxima vez que necesites lógica con ciclos, rotaciones o eventos periódicos, recuerda que el operador módulo puede ser tu mejor aliado.

Si quieres aprender más sobre cómo usar Python en tus proyectos, echa un vistazo a nuestro curso interactivo Introduction to Data Science in Python.