I1 — Bases Python et représentation des nombres

Objectif du chapitre. Maîtriser les bases de Python (variables, types, boucles, fonctions, listes, dictionnaires) et la représentation des nombres (entiers, flottants IEEE 754, erreurs d'arrondi). Ce chapitre est le socle de tout le reste de l'informatique pour tous (IPT) : les chapitres suivants (algorithmes et complexité, calcul numérique, numpy/SQL) s'appuient sur ces bases.

Chapitres de l'IPT

Ce chapitre fait partie de la scission de l'ancien chapitre unique « Informatique pour tous (IPT) ». Les chapitres frères : I1 — Algorithmes et complexité, I1 — Calcul numérique, I1 — numpy et SQL.

Notions

1. Bases de Python

Variables et types. Une variable est un nom qui référence un objet ; les types usuels sont : int (entier arbitraire), float (flottant IEEE 754), str (chaîne), bool (True/False), list (séquence mutable), dict (table clé/valeur), tuple (séquence immutable), set (ensemble). Python est dynamiquement typé (le type est attaché à l'objet, pas à la variable) et fortement typé (pas de conversion implicite dangereuse : on ne peut pas additionner un int et une str).

x = 5          # x référence un objet int
x = "bonjour"  # x référence maintenant un objet str (le 5 n'existe plus)
type(x)        # <class 'str'>

Boucles. La boucle for parcourt un itérable (liste, range, ...) ; la boucle while répète tant qu'une condition est vraie ; les instructions break (sortie immédiate) et continue (passer à l'itération suivante) contrôlent le flux.

for i in range(3):   # i = 0, 1, 2
    print(i)
n = 0
while n < 5:         # répète tant que n < 5
    n += 1

Fonctions. Une fonction est définie par def ; elle peut retourner une valeur (return) ; les paramètres par défaut se déclarent avec = ; les objets mutables (listes) passés en paramètre sont modifiés in situ (attention aux effets de bord).

def carre(x, exposant=2):
    return x ** exposant

carre(3)        # 9
carre(3, 3)     # 27

Listes et dictionnaires. Une liste est indexée (lst[i], découpage lst[a:b]) ; un dictionnaire est indexé par clé (d[key], complexité moyenne $O(1)$ pour l'accès) ; les listes en compréhension ([f(x) for x in it if cond]) sont idiomatiques et performantes.

cubes = [i**3 for i in range(5) if i % 2 == 0]   # [0, 8, 32]
d = {"a": 1, "b": 2}
d["a"]   # 1

Exemple.

def somme(n):
    total = 0
    for i in range(1, n + 1):
        total += i
    return total

La complexité est $O(n)$ (une boucle de $n$ itérations) ; on peut optimiser avec la formule fermée $n(n+1)/2$ en $O(1)$.

2. Représentation des nombres

Entiers. Les entiers Python ont une précision arbitraire (pas de débordement) ; l'arithmétique est exacte (sauf la division / qui renvoie un flottant). La division entière // et le reste % sont des opérations sur entiers exactes.

Flottants. Les flottants suivent le standard IEEE 754 (64 bits : 1 signe, 11 exposant, 52 mantisse) ; ils représentent les nombres sous la forme $(-1)^s \times 1{,}m \times 2^e$ ; la précision est limitée (environ 16 chiffres significatifs en double précision) ; des erreurs d'arrondi apparaissent (par exemple $0{,}1 + 0{,}2 \neq 0{,}3$ en flottant : $0{,}30000000000000004$).

Erreurs d'arrondi. L'erreur d'arrondi s'accumule lors des calculs itératifs ; il faut éviter les comparaisons directes de flottants (utiliser une tolérance : abs(a - b) < 1e-9) ; les calculs numériques stables réduisent l'accumulation d'erreurs (par exemple sommer les petits termes en premier).

Exemple. 0.1 + 0.2 renvoie 0.30000000000000004 (pas 0.3) ; pour comparer : abs(0.1 + 0.2 - 0.3) < 1e-9 (vrai) ; l'erreur relative est $\approx 10^{-16}$ (la précision de la machine $\varepsilon_{\text{mach}} \approx 2{,}2 \times 10^{-16}$).

Capacités exigibles

Ce chapitre porte les bases de l'IPT. Les deux capacités exigibles de l'IPT sont traitées dans le chapitre I1 — Algorithmes et complexité : I1.complexite-algorithme et I1.dichotomie. Ici, on acquiert le vocabulaire et les outils (types, boucles, fonctions, flottants) nécessaires pour les mettre en œuvre.

Ce qui tombe en colle et en DS

• Écrire un petit programme Python utilisant variables, boucles for/while, fonctions et listes.
• Expliquer pourquoi 0.1 + 0.2 != 0.3 et comment comparer des flottants (tolérance).
• Distinguer les types int (précision arbitraire) et float (IEEE 754, précision limitée).

Pièges classiques

• Flottants : comparaison directe : il ne faut pas comparer directement deux flottants avec == (sinon on obtient des résultats faux à cause des erreurs d'arrondi) ; il faut utiliser une tolérance : abs(a - b) < 1e-9 ; par exemple 0.1 + 0.2 == 0.3 renvoie False (car 0.1 + 0.2 = 0.30000000000000004) ; abs(0.1 + 0.2 - 0.3) < 1e-9 renvoie True.
• Objets mutables en paramètre : une liste passée en paramètre est modifiée in situ ; il ne faut pas supposer que la fonction travaille sur une copie (sinon on a des effets de bord inattendus) ; pour éviter, copier la liste (lst.copy()) avant de la modifier.
• Division / vs // : / renvoie un flottant (5/2 = 2.5) ; // renvoie un entier (5//2 = 2) ; il ne faut pas confondre les deux (sinon on a un flottant là où on attend un entier, par exemple pour un index).

Pour aller plus loin

Annales utilisables sur ce chapitre : voir la page générale Ressources, exercices et annales pour les manuels recommandés et les banques d'exercices gratuites.