Deux sortes de nombres, une seule sorte de vérité
Les types numériques que tu utiliseras au quotidien sont int et float, plus bool pour les valeurs vrai/faux. Ça suffit pour presque toute l'arithmétique et la logique dont un programme Python normal a besoin.
Python considère parfois les booléens comme un sous-type des entiers — True est littéralement 1 et False est littéralement 0 — ce qui ouvre quelques astuces utiles plus tard.
Arithmétique sur les entiers
Les entiers en Python ne débordent jamais. Ça a l'air sans importance jusqu'à ce que tu écrives ta première fonction factorielle et que tu réalises que la plupart des autres langages auraient silencieusement basculé vers un nombre négatif à ce stade.
Les deux produisent des réponses exactes, peu importe la taille. La mémoire est le seul plafond.
Les opérateurs arithmétiques sont ceux auxquels tu t'attends, plus quelques-uns :
Trois choses à retenir de cette liste :
/renvoie toujours un float en Python 3, même quand les deux côtés sont des entiers.10 / 2te donne5.0, pas5. Si tu veux un entier, utilise//.//arrondit vers l'infini négatif, donc-7 // 2vaut-4, pas-3. Inhabituel, mais cohérent.%donne le reste, et c'est pratique pour « ce nombre est-il pair ? » (n % 2 == 0) et pour boucler autour d'une plage fixe.
Les flottants et leur piège célèbre
Les flottants sont imparfaits par conception. Ils sont stockés en binaire, qui ne peut pas représenter la plupart des fractions décimales exactement. L'exemple classique :
La première ligne affiche 0.30000000000000004. La seconde affiche False. Chaque langage qui suit la norme IEEE 754 — Python, JavaScript, Java, C — a ce comportement. Ce n'est pas un bug Python.
En pratique, ça veut dire deux choses :
- Ne compare pas des flottants avec
==. Si tu as besoin de « assez proche », utilisemath.isclose(a, b)ou vérifie siabs(a - b) < une_tolérance. - Pour l'argent, utilise
decimal.Decimal. Le moduledecimalde la bibliothèque standard donne une arithmétique décimale exacte — pas de surprises comme0.1 + 0.2. Il est plus lent qu'un float, c'est pour ça que ce n'est pas le défaut, mais c'est le bon choix pour la monnaie.
Convertir entre types numériques
Python ne convertit pas silencieusement un entier en chaîne ou une chaîne en nombre. Tu le demandes explicitement :
Les conversions invalides lèvent ValueError :
>>> int("hello")
ValueError: invalid literal for int() with base 10: 'hello'
Le message d'erreur est direct et facile à traiter. Nettoie l'entrée ou attrape l'exception.
Les booléens, un peu plus en profondeur
True et False sont les deux valeurs booléennes — écrites exactement comme ça, majuscule au début. La plupart des comparaisons produisent l'une d'elles :
Les opérateurs booléens sont and, or et not, écrits comme des mots anglais plutôt que comme des symboles :
Une subtilité utile à connaître : and et or ne renvoient pas forcément True ou False — ils renvoient la valeur qui a décidé de l'expression. 0 or "fallback" renvoie "fallback" ; 5 and 10 renvoie 10. Ça te permet d'écrire de petits défauts comme name = user_input or "anonymous", mais ça vaut aussi la peine de comprendre si un test booléen te donne un jour un type inattendu.
Truthy et falsy
Python traite beaucoup de valeurs comme « plutôt vraies » ou « plutôt fausses » quand tu les utilises dans un contexte booléen comme if ou while. Les valeurs falsy sont :
False0,0.0None- Les conteneurs vides :
"",[],{},set(),()
Tout le reste est truthy. Ça te permet d'écrire des tests plus naturels :
Lis if name: comme « si name contient quelque chose ». Beaucoup plus propre que if name != "":. Juste attention avec les nombres — if count: traitera 0 comme « saute », ce qui est généralement mais pas toujours ce que tu veux. Si zéro est une valeur légitime, utilise if count is not None: à la place.
Arithmétique sur les booléens
Parce que les booléens sont des entiers, tu peux faire de l'arithmétique dessus :
Cette astuce revient assez souvent pour être gardée sous le coude. Si tu veux compter combien d'éléments d'une liste passent un test, fais la somme d'un générateur qui renvoie des booléens :
À retenir en pratique
- Les entiers ne débordent jamais. Utilise-les librement.
/renvoie un float ; utilise//quand tu veux une division entière.- Ne compare pas les flottants avec
==; compare avec une tolérance, ou utiliseDecimalpour l'argent. - La truthiness rend les conditions plus lisibles — tant que tu te souviens que
0et les chaînes vides sont falsy.
Ensuite : input et print, les deux outils qui transforment tes scripts de programmes silencieux en conversations.
Questions fréquentes
Quelle est la différence entre int et float en Python ?
Un int est un nombre entier sans virgule ; un float est un nombre avec virgule. Les entiers en Python peuvent être de n'importe quelle taille — pas de dépassement. Les flottants suivent la norme IEEE 754, ce qui veut dire qu'ils peuvent perdre de minuscules quantités de précision dans l'arithmétique décimale.
Pourquoi 0.1 + 0.2 n'est pas égal à 0.3 en Python ?
Parce que les nombres à virgule flottante binaires ne peuvent pas représenter la plupart des décimaux exactement. 0.1 + 0.2 s'évalue à 0.30000000000000004. Ce n'est pas un bug Python — chaque langage avec des flottants IEEE 754 a le même comportement. Pour des maths décimales exactes, utilise le module decimal.
Qu'est-ce que les valeurs truthy et falsy en Python ?
Python traite beaucoup de valeurs comme vraies ou fausses dans des contextes booléens, même si elles ne sont pas littéralement True ou False. Zéro, les chaînes vides, les listes vides, les dictionnaires vides et None sont falsy ; la plupart des autres valeurs sont truthy. if my_list: se lit « si la liste contient quelque chose ».
