Division entière Python : // et nombres négatifs
Comprends pourquoi -7 // 3 vaut -3 en Python, le signe du modulo, la différence avec int(a / b) et l'application aux indices cycliques d'une liste.
Ton calcul marche avec des nombres positifs, puis une valeur négative décale le résultat d'une unité. En Python, la division entière suit une direction précise : vers le bas sur la droite des nombres.
En bref
Avec des entiers Python, a // b donne le quotient arrondi vers moins l'infini : -7 // 3 vaut -3, alors que int(-7 / 3) vaut -2. Le reste a % b vérifie a == b * (a // b) + a % b et prend le signe du diviseur, sauf s'il est nul. Utilise divmod(a, b) pour obtenir le quotient et le reste ensemble. Le diviseur doit être non nul.
Quelle différence entre /, // et int(a / b) ?
Sur deux entiers, / produit un flottant et // un entier. La conversion int() d'un flottant supprime sa partie fractionnaire en allant vers zéro. Les résultats coïncident pour de petits quotients positifs ; un quotient négatif non entier les sépare.
print(7 / 3)print(7 // 3)print(-7 // 3)print(int(-7 / 3))print(7.0 // 3)try: print(7 // 0)except ZeroDivisionError as error: print(type(error).__name__ + ":", error)$ python3 operators.py2.33333333333333352-3-22.0ZeroDivisionError: integer division or modulo by zeroLe quotient mathématique de -7 par 3 est compris entre -3 et -2. Le plancher est -3, le plus grand entier inférieur ou égal à ce quotient. Aller vers zéro donne -2.
Attention au type : 7.0 // 3 produit 2.0, un flottant. L'opérateur // n'est donc pas une promesse de résultat de type int pour tous les opérandes. La suite utilise exclusivement des entiers Python ordinaires.
Pourquoi le reste de -7 % 3 vaut-il 2 ?
Le quotient et le reste doivent reconstruire le nombre de départ. Avec q = -3, tu as 3 * (-3) = -9 ; il reste 2 pour atteindre -7.
- 3 * q-9q = -3
- +1-8
- +2-7a atteint, r = 2
Quand le diviseur est positif, le reste est compris entre zéro inclus et ce diviseur exclu. S'il est négatif, le reste est négatif ou nul. Le programme montre les quatre combinaisons de signes, puis une division exacte.
for a, b in [(7, 3), (-7, 3), (7, -3), (-7, -3), (-6, 3)]: q, r = divmod(a, b) print(a, b, q, r, a == b * q + r)$ python3 signs.py7 3 2 1 True-7 3 -3 2 True7 -3 -3 -2 True-7 -3 2 -1 True-6 3 -2 0 TrueChaque ligne contient a, b, le quotient, le reste et la vérification de l'identité. Ainsi, 7 % -3 vaut -2. Le reste n'est pas systématiquement positif : son signe suit celui de b.
Pourquoi éviter int(a / b) pour une division entière exacte ?
Passer par / introduit un flottant avant la conversion. Ce flottant peut déjà avoir perdu une unité quand les entiers sont grands. Le convertir ensuite ne récupère pas l'information.
n = 2 ** 53 + 1print(n)print(n // 1)print(int(n / 1))$ python3 precision.py900719925474099390071992547409939007199254740992Avec les flottants binaires de cet environnement, 2 ** 53 + 1 ne survit pas à ce passage par la division flottante. Garde // quand tu veux le plancher exact de deux entiers.
Si ton contrat exige une troncature vers zéro, calcule le quotient des valeurs positives et rétablis son signe. Cette fonction reste dans l'arithmétique entière ; un diviseur nul provoque toujours une exception.
def trunc_div(a, b): magnitude_a = -a if a < 0 else a magnitude_b = -b if b < 0 else b q = magnitude_a // magnitude_b return -q if (a < 0) != (b < 0) else q
for a, b in [(-7, 3), (7, -3), (-7, -3), (2 ** 53 + 1, 1)]: print(a, b, trunc_div(a, b))$ python3 truncate.py-7 3 -27 -3 -2-7 -3 29007199254740993 1 9007199254740993Ne remplace pas toutes tes divisions par cette fonction : elle répond à un autre choix d'arrondi. Décide d'abord ce que ton calcul attend.
Comment utiliser le modulo pour parcourir une liste en boucle ?
Pour une liste non vide de longueur n, position % n reste entre 0 et n - 1, même si position est négative. Tu peux ainsi convertir une position quelconque en indice utilisable.
values = [5, 6, 7]for position in range(-2, 5): index = position % len(values) print(position, index, values[index])print(values)$ python3 cycle.py-2 1 6-1 2 70 0 51 1 62 2 73 0 54 1 6[5, 6, 7]La position -1 désigne le dernier élément ; 3 revient au premier. Une position trop négative pour l'indexation directe, comme -100, peut aussi être ramenée dans les bornes avec le modulo.
Une liste vide demande un traitement avant le calcul : sa longueur est zéro. Dans l'exercice ci-dessous, le contrat impose de renvoyer une nouvelle liste vide. Il exige aussi de conserver l'entrée et de gérer plusieurs tours. Le modulo fournit l'indice ; à toi de construire le résultat.
take_cyclic
Implémente take_cyclic(values, start, count) : accepte un départ négatif, reviens au début après le dernier élément et garde values intacte.
Pour un autre usage du reste, le filtrage de listes utilise % 2 pour reconnaître les valeurs paires. Si ton résultat modifie l'entrée sans que tu le veuilles, vérifie les règles de copie des listes.
Questions fréquentes
Est-ce que // arrondit à l'entier le plus proche ?
Non. Il choisit le plancher. Avec des entiers, 8 // 3 vaut 2, même si le quotient est plus proche de 3.
Est-ce que le modulo est toujours positif ?
Non. Avec des entiers Python, le reste non nul a le signe du diviseur. Pour une longueur de liste positive, il est donc positif ou nul.
Que se passe-t-il avec un diviseur nul ?
Les opérateurs /, //, % et la fonction divmod lèvent ZeroDivisionError sur des entiers. Traite séparément une entrée vide avant d'utiliser sa longueur comme diviseur.
Peut-on appliquer cette règle à tous les types numériques ?
Cet article traite les int ordinaires. Un float introduit des arrondis et un type comme Decimal peut avoir d'autres règles. Consulte le contrat du type utilisé.
Sources
