Comprendre les nombres en Python

Python possède trois types numériques intégrés : les entiers (int), les nombres à virgule flottante (float) et les nombres complexes (complex). Cette page explique le fonctionnement de chaque type, comment effectuer des opérations arithmétiques avec eux, les pièges courants, la conversion de types et les fonctions mathématiques fournies par la bibliothèque standard.

Nombres entiers

Un entier est un nombre entier — positif, négatif ou zéro — sans virgule décimale. En Python, les entiers ont une précision illimitée : il n'y a pas de taille maximale fixe comme en C ou en Java. Python peut travailler sans problème avec des nombres comportant des centaines de chiffres.

x = 10
y = -5
z = 0

# Python integers have no fixed size limit
big = 2 ** 100
print(big)  # 1267650600228229401496703205376

Arithmétique sur les entiers

Notez que / retourne toujours un float même lorsque le résultat est un nombre entier (6 / 2 donne 3.0). Utilisez // quand vous avez besoin d'un résultat entier.

Littéraux entiers : binaire, octal et hexadécimal

Python accepte les littéraux entiers en quatre bases. Les quatre créent le même objet int — le préfixe indique simplement à Python comment interpréter les chiffres.

decimal     = 255        # base 10 — no prefix
binary      = 0b11111111 # base 2  — prefix 0b
octal       = 0o377      # base 8  — prefix 0o
hexadecimal = 0xFF       # base 16 — prefix 0x

print(decimal, binary, octal, hexadecimal)
# 255 255 255 255

# Convert an int back to a string in a given base
print(hex(255))   # '0xff'
print(bin(255))   # '0b11111111'
print(oct(255))   # '0o377'

Vérifier le type

Utilisez type() pour confirmer le type d'une valeur, ou isinstance() pour vérifier son appartenance :

print(type(42))            # <class 'int'>
print(isinstance(42, int)) # True

Nombres flottants

Un float est un nombre avec une virgule décimale (ou un exposant). Les flottants Python sont des valeurs double précision IEEE 754 sur 64 bits, ce qui offre environ 15 à 17 chiffres décimaux significatifs de précision.

x = 10.5
y = -5.2
z = 0.0
e = 1.5e3   # scientific notation — same as 1500.0

Arithmétique sur les flottants

Précision des nombres flottants

Parce que les flottants sont stockés en binaire, certaines fractions décimales ne peuvent pas être représentées exactement. C'est une propriété de l'arithmétique IEEE 754, et non un bug de Python :

print(0.1 + 0.2)          # 0.30000000000000004
print(0.1 + 0.2 == 0.3)   # False

Lorsqu'une arithmétique décimale exacte est nécessaire (par exemple, dans les calculs financiers), utilisez le module decimal de la bibliothèque standard plutôt que float.

Arrondi et opérations utiles sur les flottants

import math

print(round(3.14159, 2))  # 3.14  — round to 2 decimal places
print(math.floor(3.7))    # 3     — largest integer <= value
print(math.ceil(3.2))     # 4     — smallest integer >= value
print(math.sqrt(16))      # 4.0   — square root
print(abs(-7.5))          # 7.5   — absolute value

Nombres complexes

Un nombre complexe possède une partie réelle et une partie imaginaire. En Python (suivant la convention en ingénierie), l'unité imaginaire s'écrit j ou J, et non i.

x = 10 + 5j
y = -5 + 3j
z = 0 + 0j        # equivalent to complex(0, 0)
w = complex(2, -3) # constructor: real=2, imag=-3

Accéder aux parties réelle et imaginaire

z = 3 + 4j
print(z.real)   # 3.0
print(z.imag)   # 4.0
print(abs(z))   # 5.0  — magnitude: sqrt(3^2 + 4^2)

Arithmétique sur les nombres complexes

Les nombres complexes ne peuvent pas être comparés avec < ou > car il n'existe pas d'ordre naturel dans le plan complexe. Seuls == et != sont pris en charge.

Conversion de types

Python ne convertit pas silencieusement les types lors des affectations, mais l'arithmétique entre différents types numériques suit des règles bien définies :

Vous pouvez convertir entre les types explicitement avec les constructeurs intégrés :

# int → float
print(float(42))       # 42.0

# float → int (truncates toward zero, no rounding)
print(int(3.9))        # 3
print(int(-3.9))       # -3

# str → int or float
print(int("100"))      # 100
print(float("3.14"))   # 3.14

# int → complex
print(complex(5))      # (5+0j)

Notez que la conversion d'un float en int tronque — elle n'arrondit pas. Utilisez d'abord round() si vous avez besoin d'un arrondi.

Le module math

Le module math fournit des fonctions mathématiques supplémentaires pour les nombres réels.

import math

print(math.pi)          # 3.141592653589793
print(math.e)           # 2.718281828459045

print(math.log(math.e)) # 1.0   — natural log
print(math.log10(1000)) # 3.0
print(math.pow(2, 10))  # 1024.0 — float result (use ** for int result)
print(math.factorial(5)) # 120
print(math.gcd(12, 8))  # 4

Pour les opérations sur les nombres complexes, utilisez cmath à la place de math :

import cmath

z = 1 + 1j
print(cmath.phase(z))   # 0.7853981633974483  — angle in radians (π/4)
print(cmath.polar(z))   # (1.4142135623730951, 0.7853981633974483) — (r, θ)

Quand utiliser chaque type

Pour les sujets connexes, consultez le chapitre Variables Python pour savoir comment les nombres sont stockés dans des variables, le chapitre Opérateurs Python pour l'ensemble complet des opérateurs numériques, et Casting Python pour les détails sur la conversion de types.

Pratique