Arithmétique — division, restes et le piège du décimal

Le problème que nous résolvons

Il y a 17 livres et une boîte en contient 5. Combien de boîtes, et combien de livres restent ?

La réponse n'est pas 17 / 5. Cela donne 3.4, et 3,4 boîte, ça n'existe pas. Il vous faut deux réponses distinctes : combien de boîtes complètes et ce qu'il en reste. Python a un opérateur pour chacune, et ce sont deux des plus utiles que vous apprendrez — pagination, découpage des secondes en heures et minutes, test de parité d'un nombre, tout cela vient de là.

Il y a une seconde chose qui arrête tout le monde la première fois qu'on la voit : en Python, 0.1 + 0.2 ne donne pas 0.3. Pourquoi, et quoi faire face à cela, fait aussi partie de ce chapitre.

À la fin de ce chapitre, vous pourrez

• Utiliser les sept opérateurs arithmétiques
• Dire quel calcul passe en premier, et quand il faut des parenthèses
• Reconnaître où // et % sont le bon outil
• Expliquer pourquoi / produit toujours un décimal, même quand la division est exacte
• Écrire des calculs qui respectent les limites de précision des nombres décimaux

Prérequis : Variables et types.

Les sept opérateurs

print(10 + 3)
print(10 - 3)
print(10 * 3)
print(10 / 3)
print(10 // 3)
print(10 % 3)
print(10 ** 3)

13
7
30
3.3333333333333335
3
1
1000

Les trois derniers méritent un mot :

• // — division entière. Divise et garde la partie entière, en jetant le reste
• % — modulo, le reste. Ce qu'il reste après la division
• ** — puissance. 10 ** 3 fait dix au cube

/ produit toujours un décimal. Même 10 / 5 renvoie 2.0, et non 2. Si le type dépendait du fait que la division tombe juste ou non, le comportement d'un programme serait imprévisible ; Python garde donc une seule règle ici : / donne un float. Quand vous avez besoin d'un nombre entier, utilisez //.

Résoudre le problème des boîtes

books = 17
per_box = 5

full_boxes = books // per_box
left_over = books % per_box

print("Full boxes:", full_boxes)
print("Left over :", left_over)

Full boxes: 3
Left over : 2

Trois boîtes se remplissent et 2 livres restent dehors. // et % vont toujours par paire — l'un dit « combien d'unités entières », l'autre « ce qu'il en reste ».

Cette même paire se retrouve à plein d'autres endroits :

total_seconds = 500

minutes = total_seconds // 60
seconds = total_seconds % 60

print(minutes, "min", seconds, "sec")

8 min 20 sec

Et % est la façon de tester la parité. Divisez n'importe quel nombre par 2 : le reste est 0 (pair) ou 1 (impair) :

print(14 % 2)
print(15 % 2)

0
1

C'est exactement sur ce reste qu'un chapitre ultérieur sur les conditions (if) s'appuiera.

Quel calcul passe en premier

Python suit les règles ordinaires de l'arithmétique — multiplications et divisions avant additions et soustractions :

print(10 + 5 * 2)
print((10 + 5) * 2)

20
30

Sur la première ligne, 5 * 2 a eu lieu en premier, puis 10 a été ajouté. Sur la seconde, les parenthèses ont changé l'ordre.

De la plus forte à la plus faible priorité :

1. **
2. *, /, //, %
3. +, -

print(2 + 3 * 4 ** 2)

50

4 ** 2 vaut 16, puis 3 * 16 vaut 48, puis 2 + 48 vaut 50.

En cas de doute, mettez des parenthèses. Même en connaissant les règles, (a + b) / 2 est préférable à a + b / 2 — la personne qui lira le code après vous n'aura aucune règle à se rappeler. Des parenthèses en trop ne ralentissent pas le code ; elles le rendent seulement plus clair.

C'est l'erreur de débutant la plus courante, et elle apparaît dès qu'on fait une moyenne :

a = 10
b = 20
c = 30

wrong = a + b + c / 3
right = (a + b + c) / 3

print("Wrong:", wrong)
print("Right:", right)

Wrong: 40.0
Right: 20.0

Le programme n'a levé aucune erreur. Rien en rouge, rien de cassé — juste une mauvaise réponse. C'est la classe de bug la plus dangereuse qui soit, car Python ne vous préviendra pas. Seul un contrôle de l'arithmétique de votre part permet de le détecter.

Le piège du décimal

print(0.1 + 0.2)

0.30000000000000004

Ce n'est pas de la faute de Python. Les ordinateurs stockent les nombres en base deux, et 0.1 ne peut pas s'écrire exactement en base deux — tout comme 1/3 ne peut pas s'écrire exactement en décimal, où 0.3333... continue à l'infini. L'ordinateur stocke donc quelque chose d'extrêmement proche, et additionner deux de ces valeurs rend la minuscule différence visible. JavaScript, Java et C se comportent tous de la même façon.

Deux conséquences pratiques :

Un — arrondissez à l'affichage :

total = 0.1 + 0.2
print(round(total, 2))

0.3

round(total, 2) signifie : gardez deux chiffres après la virgule.

Deux — ne comparez jamais deux décimaux avec == :

print(0.1 + 0.2 == 0.3)

False

C'est le piège qui produit des réponses fausses dans les calculs financiers. Les projets sérieux ne gardent pas d'argent dans un float — ils stockent la plus petite unité sous forme d'entier (49.99 devient 4999), ou ils utilisent le module decimal à part. Pour l'instant, sachez seulement où se situe la limite ; les modules viendront plus tard.

Un exemple complet

packing.py :

# Work out packing and shipping for one order
total_items = 47
items_per_box = 6
box_cost = 35.5

full_boxes = total_items // items_per_box
loose_items = total_items % items_per_box

# A partly filled box still costs a full box
boxes_needed = full_boxes
if loose_items > 0:
    boxes_needed = full_boxes + 1

shipping = boxes_needed * box_cost

print("Items        :", total_items)
print("Full boxes   :", full_boxes)
print("Loose items  :", loose_items)
print("Boxes needed :", boxes_needed)
print("Shipping     :", round(shipping, 2))

Items        : 47
Full boxes   : 7
Loose items  : 5
Boxes needed : 8
Shipping     : 284.0

La ligne if n'a pas encore été présentée — c'est à quoi servent les prochains chapitres. Pour l'instant, lisez-la simplement : s'il reste des articles en vrac, il faut une boîte de plus.

En cas de problème

ZeroDivisionError: division by zero Quelque chose a été divisé par zéro. C'est indéfini en mathématiques aussi, donc Python s'arrête. Il faut vérifier le diviseur avant de diviser — ce qui devient facile une fois que vous maîtrisez les conditions.

10 / 5 a donné 2.0 et j'ai besoin de 2 Utilisez //, ou écrivez int(10 / 5). Le premier est meilleur : l'intention est visible dans le code.

// donne des résultats étranges sur les nombres négatifs -7 // 2 donne -4, et non -3. Python arrondit vers le bas, pas vers zéro. À retenir si vous travaillez avec des négatifs.

Le calcul semble juste mais la réponse est fausse Comptez les parenthèses, puis séparez chaque étape sur sa propre ligne et affichez-la. L'erreur est presque toujours une question de priorité des opérateurs.

Une longue traîne de chiffres après la virgule Ce n'est pas une erreur, c'est le comportement des décimaux. Raccourcissez avec round() à l'affichage.

À vous de jouer

Écrivez un fichier appelé time_split.py qui découpe un nombre de secondes en heures, minutes et secondes.

Partez de total_seconds = 7385, et la sortie doit être :

2 h 3 m 5 s

Trois conditions :

1. N'utilisez que // et % — ne tapez aucun des résultats à la main
2. Gardez les trois valeurs dans trois variables séparées, avec des noms significatifs
3. Changez ensuite total_seconds en 59, 60, 3600 et 86399, et exécutez chacune — vérifiez que les quatre sortent correctement

Ne sautez pas cette dernière étape. Un programme qui marche pour une seule entrée ne marche pas ; un programme qui tient aussi aux limites, lui, marche.