Modulo en Python : comprendre %, // et divmod avec exemples

En Python, le modulo sert à récupérer le reste d’une division. Si vous écrivez 10 % 3, Python renvoie 1, parce que 10 contient trois fois 3, avec 1 qui reste. C’est une opération simple, mais elle apparaît partout : tests pair/impair, cycles, pagination, indices de listes, cryptographie de base, algorithmes et calculs sur des entiers.

Le point à retenir est celui-ci : % donne le reste, // donne le quotient entier, et divmod() renvoie les deux en une seule fois.

nombre = 10
diviseur = 3

quotient = nombre // diviseur
reste = nombre % diviseur

print(quotient)  # 3
print(reste)     # 1

La réponse courte

Pour calculer un modulo en Python, utilisez l’opérateur %.

reste = 10 % 3
print(reste)  # 1

Pour obtenir en même temps le quotient et le reste, utilisez divmod().

quotient, reste = divmod(10, 3)

print(quotient)  # 3
print(reste)     # 1

Cette relation reste vraie pour les entiers :

x = 10
y = 3

print(x == (x // y) * y + (x % y))  # True

Autrement dit, Python garde la cohérence suivante :

x = quotient * diviseur + reste

%, // et / : trois divisions à ne pas confondre

En Python, trois opérateurs se ressemblent mais ne répondent pas à la même question.

La confusion la plus fréquente consiste à croire que // “coupe simplement les décimales”. Pour les nombres positifs, cela donne souvent cette impression. Mais en réalité, // applique une division entière arrondie vers le bas. Cette nuance devient importante avec les nombres négatifs.

print(10 // 3)    # 3
print(-10 // 3)   # -4

-10 / 3 vaut environ -3.33. L’arrondi vers le bas donne donc -4, pas -3.

Pourquoi divmod() est parfois plus clair

La fonction divmod(a, b) renvoie directement un tuple (quotient, reste). Pour les entiers, elle donne le même résultat que (a // b, a % b).

q, r = divmod(25, 4)

print(q)  # 6
print(r)  # 1

Cette écriture est utile quand vous avez besoin des deux valeurs dans la même logique. Par exemple, pour convertir un nombre de secondes en minutes et secondes restantes :

total_secondes = 367

minutes, secondes = divmod(total_secondes, 60)

print(minutes)   # 6
print(secondes)  # 7

Le code est plus lisible que deux opérations séparées :

minutes = total_secondes // 60
secondes = total_secondes % 60

Les deux versions sont correctes. divmod() devient simplement plus expressif quand le quotient et le reste forment un couple logique.

Le cas important des nombres négatifs

Le modulo en Python peut surprendre lorsque le nombre ou le diviseur est négatif. La règle à retenir : le reste a le même signe que le diviseur, ou vaut zéro.

print(10 % 3)    # 1
print(-10 % 3)   # 2
print(10 % -3)   # -2
print(-10 % -3)  # -1

Pourquoi -10 % 3 vaut-il 2 ? Parce que Python conserve l’identité :

x == (x // y) * y + (x % y)

Vérifions avec -10 et 3 :

x = -10
y = 3

quotient = x // y
reste = x % y

print(quotient)  # -4
print(reste)     # 2
print(quotient * y + reste)  # -10

Ce comportement est très pratique pour les cycles. Par exemple, si vous voulez revenir au dernier élément d’une liste quand un indice passe sous zéro :

jours = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"]

index = -1 % len(jours)

print(index)        # 6
print(jours[index]) # dimanche

Cas pratiques du modulo en Python

Le modulo n’est pas seulement une notion mathématique. C’est un outil très concret pour écrire du code plus propre.

Tester si un nombre est pair ou impair

Un entier est pair si le reste de sa division par 2 vaut 0.

nombre = 42

if nombre % 2 == 0:
    print("pair")
else:
    print("impair")

Ce test est l’un des usages les plus courants de %.

Créer un cycle

Le modulo permet de revenir au début d’une séquence quand on dépasse sa longueur.

couleurs = ["rouge", "vert", "bleu"]

for i in range(8):
    couleur = couleurs[i % len(couleurs)]
    print(i, couleur)

Résultat :

0 rouge
1 vert
2 bleu
3 rouge
4 vert
5 bleu
6 rouge
7 vert

C’est utile pour alterner des couleurs, parcourir des états, gérer un tour de jeu ou répéter une séquence.

Construire une pagination

Pour savoir combien de pages sont nécessaires, on combine souvent division entière et reste.

elements = 53
par_page = 10

pages = elements // par_page

if elements % par_page != 0:
    pages += 1

print(pages)  # 6

Ici, 53 // 10 donne 5, mais il reste 3 éléments. Il faut donc une sixième page.

On peut aussi écrire une version compacte :

pages = (elements + par_page - 1) // par_page
print(pages)  # 6

Cette formule évite le if, mais elle est moins évidente pour un débutant. Dans un tutoriel ou une base de code lisible, la version avec % est souvent plus pédagogique.

Extraire des heures, minutes et secondes

divmod() est très pratique pour convertir une durée.

duree = 7384

heures, reste = divmod(duree, 3600)
minutes, secondes = divmod(reste, 60)

print(heures)    # 2
print(minutes)   # 3
print(secondes)  # 4

Ce code dit clairement ce qu’il fait : on extrait d’abord les heures, puis les minutes, puis les secondes.

Travailler avec une horloge

Le modulo est naturel dès qu’une valeur “tourne” dans un intervalle fixe.

heure = 22
ajout = 5

nouvelle_heure = (heure + ajout) % 24

print(nouvelle_heure)  # 3

Après 23, on revient à 0. Le modulo exprime exactement cette logique.

Les erreurs fréquentes

Diviser par zéro

Comme pour une division classique, utiliser % avec un diviseur nul provoque une erreur.

print(10 % 0)

Python lève alors une exception ZeroDivisionError.

ZeroDivisionError: integer modulo by zero

Si le diviseur vient d’une entrée utilisateur ou d’un calcul, testez-le avant d’appliquer le modulo.

diviseur = 0

if diviseur != 0:
    print(10 % diviseur)
else:
    print("Impossible de calculer un modulo avec zéro.")

Utiliser % avec des nombres flottants sans prudence

Python accepte le modulo avec des nombres flottants.

print(5.5 % 2.0)  # 1.5

Mais les flottants peuvent introduire des imprécisions, comme dans d’autres calculs décimaux.

print(0.3 % 0.1)

Le résultat peut surprendre à cause de la représentation binaire des nombres décimaux. Pour des calculs financiers ou décimaux exacts, il vaut mieux regarder du côté de decimal.Decimal.

Confondre modulo et formatage de chaîne

L’opérateur % sert aussi à l’ancien style de formatage de chaînes.

nom = "Ada"
message = "Bonjour %s" % nom

print(message)  # Bonjour Ada

Ce n’est pas un modulo mathématique : Python utilise ici une surcharge de l’opérateur pour formater du texte. Dans du code moderne, les f-strings sont souvent plus lisibles.

nom = "Ada"
message = f"Bonjour {nom}"

Calculer une puissance modulaire de façon inefficace

Pour calculer une puissance modulo un nombre, évitez cette forme quand les entiers deviennent grands :

resultat = (base ** exposant) % modulo

Préférez pow(base, exposant, modulo), qui est conçu pour ce cas.

resultat = pow(7, 256, 13)
print(resultat)

C’est plus efficace et plus adapté aux calculs modulaires, notamment dans certains algorithmes liés aux nombres entiers.

Mini-exercices pour vérifier que vous avez compris

Essayez de prédire les résultats avant d’exécuter le code.

print(17 % 5)
print(17 // 5)
print(divmod(17, 5))

print(-17 % 5)
print(-17 // 5)
print(divmod(-17, 5))

for i in range(10):
    print(i, i % 4)

Les réponses :

print(17 % 5)        # 2
print(17 // 5)       # 3
print(divmod(17, 5)) # (3, 2)

print(-17 % 5)        # 3
print(-17 // 5)       # -4
print(divmod(-17, 5)) # (-4, 3)

0 0
1 1
2 2
3 3
4 0
5 1
6 2
7 3
8 0
9 1

Le dernier exemple montre le comportement cyclique du modulo : avec % 4, les restes possibles sont toujours 0, 1, 2 ou 3.

Quand utiliser %, // ou divmod()

Utilisez % si vous avez seulement besoin du reste :

if nombre % 2 == 0:
    print("pair")

Utilisez // si vous avez seulement besoin du quotient entier :

paquets = objets // taille_paquet

Utilisez divmod() si vous avez besoin des deux :

paquets, reste = divmod(objets, taille_paquet)

Ce choix rend le code plus lisible. Un bon code Python ne cherche pas seulement à être court : il doit exprimer clairement l’intention.

Pour aller plus loin

Le modulo est une base utile pour plusieurs sujets déjà présents sur le site :

• l’algorithme d’Euclide étendu en Python, qui utilise les divisions successives ;
• les inverses modulaires en Python, où le modulo devient central ;
• l’identité de puissance modulo avec Python, utile pour comprendre certains calculs sur les grands entiers.

Si vous débutez, retenez surtout cette règle : % répond à la question “que reste-t-il ?”. Une fois cette idée claire, //, divmod() et les algorithmes modulaires deviennent beaucoup plus faciles à lire.

Références

• Documentation Python – Expressions : division entière et modulo
• Documentation Python – Fonction divmod()
• Documentation Python – Fonction pow()