Int en Python - créer, convertir et calculer sans erreurs

Un compteur, un identifiant ou une quantité doivent souvent être manipulés comme des nombres entiers plutôt que comme du texte ou des décimales. En Python, le type int couvre ces besoins avec une syntaxe simple, des conversions pratiques et une précision bien plus large que celle de nombreux langages. Je vous montre comment le créer, le convertir, l’utiliser dans les calculs et éviter les erreurs les plus courantes.

Comprendre le type entier en Python

Un entier est un nombre sans partie décimale. Les valeurs 0, 42, -8 et 1_000_000 sont toutes des objets de type int. Le caractère souligné améliore simplement la lisibilité des grands nombres et ne change pas leur valeur.

age = 32
temperature = -4
population = 1_000_000

print(type(age))          # 
print(population + 500)   # 1000500

Python ne sépare pas les entiers courts et les entiers longs comme le faisaient certaines anciennes versions du langage. Un entier peut donc dépasser largement 2 milliards, à condition que la machine dispose de suffisamment de ressources. Cette précision arbitraire est très pratique pour les calculs financiers, les combinatoires ou la cryptographie, mais elle ne rend pas les opérations gigantesques instantanées.

Les entiers sont aussi immutables. Quand une variable semble changer, Python crée en réalité un nouvel objet entier au lieu de modifier l’ancien. Dans un programme courant, cette distinction reste transparente, mais elle explique certains comportements liés à la mémoire et aux performances.

Créer et convertir un entier avec int()

La fonction int() sert à construire un entier ou à convertir une valeur compatible. Avec une chaîne contenant uniquement un nombre entier, la conversion est directe.

nombre = int("250")
print(nombre + 50)  # 300

Le piège classique consiste à oublier que la valeur saisie par input() est toujours une chaîne. Même si l’utilisateur écrit 18, Python reçoit "18". Pour effectuer un calcul, il faut donc convertir la réponse.

annee = int(input("En quelle année êtes-vous né ? "))
age = 2026 - annee
print(f"Vous avez environ {age} ans.")

Convertir un nombre décimal

Avec un float, int() supprime la partie décimale et ne l’arrondit pas. Le résultat est tronqué vers zéro, ce qui donne des résultats parfois surprenants avec les nombres négatifs.

print(int(8.99))    # 8
print(int(-8.99))   # -8

Si vous voulez un véritable arrondi, utilisez plutôt round(). Pour toujours descendre vers l’entier inférieur ou supérieur, les fonctions math.floor() et math.ceil() sont plus explicites. Je déconseille de remplacer automatiquement tous les décimaux par des entiers, car cette opération peut supprimer une information importante.

Changer de base numérique

int() sait aussi lire une chaîne dans une base donnée. C’est utile pour le binaire, l’hexadécimal ou le traitement de données techniques.

bits = int("1010", 2)
hexadecimal = int("FF", 16)

print(bits)        # 10
print(hexadecimal) # 255

Dans le code source, les préfixes rendent également la base visible. 0b1010 représente du binaire, 0o17 de l’octal et 0xFF de l’hexadécimal. Cette notation est plus lisible qu’une conversion implicite lorsque la base a une importance métier ou technique.

Maîtriser les calculs avec les entiers

Les opérateurs arithmétiques habituels fonctionnent naturellement avec les valeurs de type int. L’addition, la soustraction et la multiplication produisent généralement un autre entier.

a = 17
b = 5

print(a + b)  # 22
print(a - b)  # 12
print(a * b)  # 85
print(a ** 2) # 289

La division demande davantage d’attention. L’opérateur / renvoie toujours un nombre flottant, même lorsque le résultat est exact. L’opérateur // renvoie une division par plancher, et non une simple suppression de la partie décimale.

La différence avec les nombres négatifs est importante. int(-3.4) renvoie -3, alors que -17 // 5 renvoie -4. Dans un calcul de pages, de blocs ou de coordonnées, je vérifie toujours cette règle avant de choisir entre // et int().

Les entiers se combinent aussi avec les flottants. Dès qu’une opération mélange les deux types, Python élargit généralement le résultat vers float. Cela peut introduire les limites habituelles de la représentation décimale binaire. Pour des montants monétaires précis, un entier exprimé en centimes ou le module decimal est souvent plus fiable.

Éviter les erreurs de conversion

Une conversion échoue lorsque la valeur ne représente pas un entier valide. int("12.5") provoque ainsi une erreur, car cette chaîne décrit un nombre décimal et non un entier écrit directement. Il faudrait d’abord la convertir en float, puis décider consciemment quoi faire de la partie décimale.

valeur = "12.5"

nombre = int(float(valeur))
print(nombre)  # 12

Pour une donnée saisie par un utilisateur, je préfère gérer explicitement les exceptions. Cela évite qu’une simple faute de frappe arrête tout le programme.

texte = input("Entrez un nombre entier : ")

try:
    nombre = int(texte)
except ValueError:
    print("La valeur saisie n'est pas un entier valide.")
else:
    print(f"Vous avez choisi {nombre}.")

Une chaîne vide, une valeur comme "douze" ou un nombre écrit avec une virgule française provoqueront aussi une ValueError. Si les données viennent d’un formulaire, d’un fichier CSV ou d’une API, validez-les avant le calcul au lieu de supposer qu’elles sont propres.

Lire aussi : Couleurs Tkinter - Maîtrisez l'art du design Python

Le cas particulier des booléens

En Python, bool est lié au type entier. True se comporte comme 1 et False comme 0.

print(int(True))   # 1
print(int(False))  # 0
print(True + 4)    # 5

Cette compatibilité est pratique pour compter des conditions, mais elle peut masquer une erreur de conception. Une fonction qui attend un âge ne devrait pas accepter silencieusement True comme la valeur 1. Selon le besoin, utilisez type(valeur) is int ou une validation métier plus précise.

Vérifier un entier et l’utiliser proprement

Pour inspecter un type, la fonction isinstance() est généralement le meilleur choix. Elle accepte aussi les classes dérivées et rend l’intention lisible.

valeur = 42

if isinstance(valeur, int):
    print("La valeur est un entier.")

Si votre objectif est de vérifier qu’une chaîne peut être convertie, testez la conversion plutôt que d’examiner chaque caractère. Cette approche prend en compte les signes positifs et négatifs, ainsi que les différentes règles acceptées par Python.

def est_un_entier(texte):
    try:
        int(texte)
        return True
    except ValueError:
        return False

Dans une fonction, les annotations rendent également le contrat plus clair. Elles n’imposent pas automatiquement le type à l’exécution, mais elles aident les outils d’analyse et les autres développeurs.

def doubler(nombre: int) -> int:
    return nombre * 2

Je conseille toutefois de ne pas transformer chaque valeur en int par réflexe. Une quantité mesurée, un prix ou un ratio peut légitimement être un float. Le bon type dépend de la précision attendue et de la manière dont la valeur sera utilisée.

Les limites à connaître avec les très grands entiers

La précision arbitraire évite le débordement classique des entiers de taille fixe. Vous pouvez calculer une puissance élevée ou une factorielle sans obtenir immédiatement une valeur fausse à cause d’une limite de 32 ou 64 bits.

resultat = 2 ** 100
print(resultat)
print(resultat.bit_length())

Cette liberté a un coût. Plus un entier contient de bits, plus les opérations et les conversions peuvent être longues. La méthode bit_length() indique le nombre de bits nécessaires pour représenter sa valeur positive, ce qui permet d’évaluer rapidement sa taille.

Python récent protège aussi certaines conversions de chaînes extrêmement longues vers des entiers. Une limite de l’ordre de 4 300 chiffres peut s’appliquer par défaut selon la version et la configuration, afin de réduire les risques de surcharge provoqués par des entrées malveillantes. Pour des fichiers légitimes contenant de très grands nombres, il faut traiter cette limite avec prudence plutôt que la désactiver sans contrôle.

Dans une application exposée sur Internet, je limite toujours la taille des entrées avant de lancer des calculs coûteux. La précision illimitée de int est un avantage de Python, pas une raison pour accepter des nombres de taille inconnue.

Un réflexe simple pour choisir le bon type

Utilisez int pour les compteurs, les index, les quantités discrètes, les identifiants numériques et les calculs où aucune fraction n’a de sens. Gardez float pour les mesures approximatives et les divisions nécessitant une partie décimale.

Avant une conversion, posez-vous trois questions. La donnée est-elle réellement entière, que faut-il faire d’une éventuelle fraction et que se passe-t-il si l’entrée est invalide ? Ces trois vérifications évitent la majorité des bugs liés à int en Python et rendent le code beaucoup plus prévisible.