Division Entière en Python : Guide Complet de l'Opérateur //

Name

Kanaries Team

Updated on 24/11/2025

La division entière (floor division) est une opération arithmétique fondamentale en Python qui divise deux nombres et arrondit le résultat vers le bas à l'entier le plus proche. Contrairement à la division régulière qui retourne un nombre à virgule flottante, la division entière utilisant l'opérateur // retourne toujours le plus grand entier inférieur ou égal au résultat. Cet article vous guidera à travers tout ce que vous devez savoir sur la division entière en Python.

Python fournit deux opérateurs de division : l'opérateur de division régulière / et l'opérateur de division entière //. Comprendre quand utiliser chacun est essentiel pour écrire du code Python efficace et sans erreur.

Vous voulez créer rapidement des visualisations de données à partir de Python Pandas DataFrame sans code ?

PyGWalker est une bibliothèque Python pour l'analyse exploratoire des données avec visualisation. PyGWalker (opens in a new tab) peut simplifier votre flux de travail d'analyse et de visualisation de données dans Jupyter Notebook, en transformant votre pandas dataframe (et polars dataframe) en une interface utilisateur alternative à Tableau pour l'exploration visuelle.

(opens in a new tab)

Qu'est-ce que la Division Entière en Python ?

La division entière est l'opération de division qui arrondit le résultat vers le bas à l'entier le plus proche. En Python, cela se fait en utilisant l'opérateur //. Le terme "floor" (plancher) vient de la fonction mathématique floor, qui arrondit toujours vers l'infini négatif.

Voici un exemple simple :

# Division régulière
print(7 / 2)   # Sortie : 3.5
 
# Division entière
print(7 // 2)  # Sortie : 3

Comme vous pouvez le voir, la division régulière retourne 3.5, tandis que la division entière retourne 3 - le plus grand entier inférieur ou égal à 3.5.

Syntaxe de la Division Entière

La syntaxe de la division entière en Python est simple :

resultat = dividende // diviseur

Où :

• dividende est le nombre à diviser
• diviseur est le nombre par lequel on divise
• resultat est le plancher de la division

Division Entière avec Différents Types de Données

Entiers

Quand les deux opérandes sont des entiers, la division entière retourne un entier :

print(10 // 3)   # Sortie : 3
print(15 // 4)   # Sortie : 3
print(20 // 5)   # Sortie : 4

Nombres à Virgule Flottante

Quand au moins un opérande est un float, la division entière retourne un float (mais toujours arrondi vers le bas) :

print(10.0 // 3)   # Sortie : 3.0
print(10 // 3.0)   # Sortie : 3.0
print(10.5 // 3)   # Sortie : 3.0

Nombres Négatifs

La division entière avec des nombres négatifs peut être délicate. Rappelez-vous, la division entière arrondit toujours vers l'infini négatif, pas vers zéro :

print(7 // 2)    # Sortie : 3
print(-7 // 2)   # Sortie : -4  (pas -3 !)
print(7 // -2)   # Sortie : -4
print(-7 // -2)  # Sortie : 3

Ce comportement est important à comprendre car -7 / 2 = -3.5, et le plancher de -3.5 est -4, pas -3.

Division Entière vs Division Régulière

# Comparaison
a = 17
b = 5
 
print(f"Division régulière : {a} / {b} = {a / b}")     # 3.4
print(f"Division entière : {a} // {b} = {a // b}")    # 3

Cas d'Utilisation Pratiques pour la Division Entière

1. Calcul de Pages ou Groupes

Quand vous devez déterminer combien de groupes complets tiennent dans un total :

total_elements = 23
elements_par_page = 5
 
pages_completes = total_elements // elements_par_page
print(f"Pages complètes : {pages_completes}")  # Sortie : 4

2. Conversion d'Unités

La division entière est utile pour les conversions d'unités :

total_secondes = 3725
 
heures = total_secondes // 3600
minutes = (total_secondes % 3600) // 60
secondes = total_secondes % 60
 
print(f"{heures}h {minutes}m {secondes}s")  # Sortie : 1h 2m 5s

3. Indexation de Tableaux et Positionnement

En travaillant avec des grilles ou des tableaux 2D :

# Convertir un index 1D en coordonnées 2D
index = 17
colonnes = 5
 
ligne = index // colonnes
colonne = index % colonnes
 
print(f"Index {index} -> Ligne : {ligne}, Colonne : {colonne}")  # Ligne : 3, Colonne : 2

4. Trouver l'Index du Milieu

Utile dans la recherche binaire et les algorithmes similaires :

def recherche_binaire(arr, cible):
    gauche, droite = 0, len(arr) - 1
 
    while gauche <= droite:
        milieu = (gauche + droite) // 2  # Division entière pour l'index du milieu
        if arr[milieu] == cible:
            return milieu
        elif arr[milieu] < cible:
            gauche = milieu + 1
        else:
            droite = milieu - 1
 
    return -1

La Fonction divmod()

Python fournit une fonction intégrée divmod() qui retourne à la fois le quotient (division entière) et le reste en une seule opération :

quotient, reste = divmod(17, 5)
print(f"17 // 5 = {quotient}")    # Sortie : 3
print(f"17 % 5 = {reste}")        # Sortie : 2

C'est plus efficace que d'appeler // et % séparément quand vous avez besoin des deux valeurs.

Division Entière avec le Module math

Vous pouvez aussi réaliser la division entière en utilisant la fonction math.floor() combinée avec la division régulière :

import math
 
resultat1 = 7 // 2
resultat2 = math.floor(7 / 2)
 
print(resultat1)  # Sortie : 3
print(resultat2)  # Sortie : 3

Les deux méthodes produisent le même résultat, mais // est plus concis et généralement préféré.

Erreurs Courantes et Comment les Éviter

Erreur 1 : Confondre Division Entière et Troncature

# La division entière arrondit vers l'infini négatif
print(-7 // 2)  # Sortie : -4
 
# La troncature (conversion en int) arrondit vers zéro
print(int(-7 / 2))  # Sortie : -3

Erreur 2 : Oublier les Résultats Float

# Si un opérande est float, le résultat est float
print(type(10 // 3))    # <class 'int'>
print(type(10.0 // 3))  # <class 'float'>

Erreur 3 : Division par Zéro

# Ceci lèvera une ZeroDivisionError
try:
    resultat = 10 // 0
except ZeroDivisionError:
    print("Impossible de diviser par zéro !")

Considérations de Performance

La division entière est généralement plus rapide que la division régulière suivie de int() ou math.floor() :

import timeit
 
# Opérateur de division entière
temps1 = timeit.timeit('7 // 2', number=1000000)
 
# Division régulière + int()
temps2 = timeit.timeit('int(7 / 2)', number=1000000)
 
print(f"Opérateur // : {temps1:.4f}s")
print(f"Méthode int(/) : {temps2:.4f}s")

FAQ

Quelle est la différence entre / et // en Python ?

L'opérateur / effectue une division vraie et retourne toujours un float, tandis que // effectue une division entière et retourne le plus grand entier inférieur ou égal au résultat. Par exemple, 7 / 2 retourne 3.5, mais 7 // 2 retourne 3.

Comment fonctionne la division entière avec les nombres négatifs ?

La division entière arrondit toujours vers l'infini négatif. Donc -7 // 2 est égal à -4, pas -3, car -4 est le plus grand entier inférieur ou égal à -3.5.

Quand dois-je utiliser la division entière au lieu de la division régulière ?

Utilisez la division entière quand vous avez besoin d'un résultat entier et voulez éviter les problèmes de précision des nombres à virgule flottante, comme lors du calcul d'indices de tableaux, du comptage de groupes complets, ou de l'implémentation d'algorithmes nécessitant une arithmétique entière.

Conclusion

La division entière en Python avec l'opérateur // est un outil puissant pour effectuer une division d'entiers qui arrondit vers le bas à l'entier le plus proche. Comprendre son comportement, surtout avec les nombres négatifs et les opérandes à virgule flottante, est crucial pour écrire du code Python correct. Que vous implémentiez des algorithmes, convertissiez des unités ou travailliez avec des indices de tableaux, la division entière est une opération essentielle dans votre boîte à outils Python.