Le langage Python
Partie 2 sur 3
4Les bases du langage
4.1Variables et types
En Python, une variable se crée simplement en lui affectant une valeur, sans déclarer son type : age = 20. Le typage est dynamique : une variable peut recevoir successivement des valeurs de types différents, chaque valeur portant son propre type. Il est aussi fort : Python refuse d’additionner un texte et un nombre sans conversion explicite (voir les types de données). Les types de base sont :
int: les nombres entiers, de taille illimitée ;float: les nombres à virgule, représentés en binaire avec une précision limitée, d’où des surprises comme0.1 + 0.2qui donne0.30000000000000004(exercice 6 ; voir le binaire) ;str: les chaînes de caractères, entre guillemets simples ou doubles, en Unicode, donc avec tous les accents et alphabets (voir le codage des caractères) ;bool: les valeurs logiquesTrueetFalse;None: la valeur « rien », qui indique l’absence de valeur.
Les chaînes formatées, précédées de la lettre f, permettent d’insérer des valeurs dans un texte : f"Bonjour {prenom}, vous avez {age} ans". Les chaînes disposent de nombreuses méthodes pour manipuler du texte : upper() et lower() changent la casse, strip() retire les espaces aux extrémités, replace() remplace un morceau de texte, split() découpe un texte en morceaux selon un séparateur, et join() fait l’inverse. On peut aussi en extraire des morceaux par leur position, comme pour les listes : "Bonjour"[0:3] vaut "Bon". Les chaînes sont non modifiables : chaque méthode renvoie une nouvelle chaîne, sans changer l’originale. Pour convertir un texte en nombre, on utilise int() ou float(), et str() pour l’inverse ; la fonction input(), qui lit ce que tape l’utilisateur, renvoie toujours un texte, qu’il faut convertir avant de calculer.
4.2Les structures de données
Python fournit quatre structures de données essentielles, directement dans le langage (figure 2) :
- la liste, une suite ordonnée et modifiable d’éléments, notée entre crochets :
notes = [12, 15, 9]. On accède aux éléments par leur position, en commençant à 0 :notes[0]vaut 12,notes[-1]désigne le dernier, etnotes[1:3]extrait une tranche. On ajoute un élément parnotes.append(17); - le tuple, une suite ordonnée mais non modifiable, notée entre parenthèses, pratique pour des valeurs qui vont ensemble, comme des coordonnées :
(48.85, 2.35); - le dictionnaire, qui associe des clés à des valeurs, comme un répertoire associe des noms à des numéros :
eleve = {"nom": "Léa", "age": 20}, eteleve["nom"]vaut"Léa". C’est l’une des structures les plus utilisées du langage ; - l’ensemble, une collection sans ordre et sans doublon, notée entre accolades, qui permet de tester très vite si un élément est présent.
4.3Conditions et boucles
Les conditions s’écrivent avec if, elif (contraction de else if, « sinon si ») et else ; les boucles avec while, qui répète tant qu’une condition est vraie, et for, qui parcourt les éléments d’une liste, d’un texte ou de toute collection :
for note in notes:
if note >= 10:
print(note, "admis")
else:
print(note, "ajourné")
for i in range(5): # i prend les valeurs 0, 1, 2, 3, 4
print(i * i)
Python offre aussi une écriture compacte pour construire une liste à partir d’une autre, appelée compréhension de liste : [x * x for x in nombres if x % 2 == 0] donne la liste des carrés des nombres pairs (exercice 4).
4.4Fonctions
Une fonction se définit avec le mot-clé def, et renvoie un résultat avec return. Les paramètres peuvent avoir des valeurs par défaut, et l’on peut les nommer lors de l’appel :
def saluer(prenom, formule="Bonjour"):
return f"{formule}, {prenom} !"
saluer("Momo") # "Bonjour, Momo !"
saluer("Léa", formule="Salut") # "Salut, Léa !"
Les fonctions sont elles-mêmes des objets, qu’on peut ranger dans des variables ou passer en paramètre à d’autres fonctions, ce qui ouvre la porte au style fonctionnel. Depuis 2015, on peut aussi indiquer le type attendu des paramètres et du résultat par des annotations, def saluer(prenom: str) -> str:, que Python n’impose pas à l’exécution, mais que des outils de vérification, comme mypy, et les éditeurs exploitent pour détecter les erreurs.
4.5Les erreurs : les exceptions
Lorsqu’une erreur survient, ouverture d’un fichier absent, division par zéro, conversion impossible, Python lève une exception, qui interrompt le programme avec un message explicite, sauf si elle est interceptée par un bloc try … except :
try:
age = int(input("Votre âge : "))
except ValueError:
print("Ce n'est pas un nombre entier.")
4.6Classes et objets
En Python, tout est objet, y compris les nombres, les fonctions et les classes. On définit une classe avec le mot-clé class ; le constructeur s’appelle __init__, et l’objet courant est passé explicitement à chaque méthode sous le nom self (voir la programmation orientée objet). Des méthodes aux noms spéciaux, entourés de deux tirets bas, permettent de définir le comportement des objets avec les opérateurs du langage : __add__ pour le signe +, __len__ pour la fonction len(), __str__ pour l’affichage.
4.7Les modules
Un programme Python se découpe en modules, des fichiers .py que l’on importe avec import. Python est fourni avec une riche bibliothèque standard : on dit qu’il est livré « piles comprises » (en anglais batteries included). Elle couvre les fichiers et les dossiers, les dates, les mathématiques, les expressions régulières, le format JSON (JavaScript Object Notation, un format texte de données structurées), le réseau, le Web, la compression, la cryptographie de base, les tests, et bien d’autres domaines :
import json
from datetime import date
print(date.today().year)
donnees = json.loads('{"nom": "Léa", "age": 20}')
4.8Itérateurs et générateurs
La boucle for de Python fonctionne avec tout objet itérable, c’est-à-dire capable de fournir ses éléments un par un : listes, chaînes, dictionnaires, fichiers, mais aussi objets définis par le programmeur. Un générateur est une fonction qui, au lieu de renvoyer une liste complète, fournit ses résultats un par un grâce au mot-clé yield, en se mettant en pause entre chacun :
def carres(n):
for i in range(n):
yield i * i
for c in carres(1_000_000): # aucun million d'éléments en mémoire
if c > 50:
break
Les valeurs ne sont calculées qu’au moment où on les demande : un générateur peut parcourir un fichier de plusieurs gigaoctets, ou une suite infinie, sans tout charger en mémoire. Le tiret bas dans 1_000_000 sert simplement à rendre le nombre plus lisible.
4.9Lire et écrire des fichiers
La lecture d’un fichier texte se fait avec la fonction open(), de préférence dans un bloc with, qui garantit que le fichier sera refermé, même en cas d’erreur. On précise l’encodage des caractères, le plus souvent UTF-8, pour éviter les surprises avec les accents :
with open("notes.txt", encoding="utf-8") as fichier:
for ligne in fichier:
print(ligne.strip())
with open("bilan.txt", "w", encoding="utf-8") as sortie:
sortie.write("Moyenne : 12.0\n")
La bibliothèque standard offre aussi des modules pour les formats courants : csv pour les tableaux exportés d’un tableur, json pour les données structurées, pathlib pour manipuler les chemins de fichiers de manière indépendante du système d’exploitation (voir les systèmes de fichiers).
Pour s’exercer
Exercice 1 : suivre la fonction moyenne
Que renvoie la fonction moyenne de la figure 1 pour les listes [12, 15, 9], [] et [10] ?
Voir la réponse
Pour [12, 15, 9], la boucle calcule 12 + 15 + 9 = 36, et la fonction renvoie 36 ÷ 3 = 12.0 : la division / donne toujours un nombre à virgule en Python 3. Pour [], la condition len(notes) == 0 est vraie, et la fonction renvoie None, ce qui évite une division par zéro. Pour [10], elle renvoie 10.0.
Exercice 2 : manipuler une liste
Avec lettres = ["a", "b", "c", "d", "e"], que valent lettres[0], lettres[-1], lettres[1:3] et len(lettres) ? Que devient la liste après lettres.append("f") ?
Voir la réponse
lettres[0] vaut "a" : les positions commencent à 0. lettres[-1] vaut "e" : les positions négatives comptent depuis la fin. lettres[1:3] vaut ["b", "c"] : la tranche inclut la position de début et exclut celle de fin. len(lettres) vaut 5. Après append, la liste contient six éléments, de "a" à "f".
Exercice 3 : compter les mots
Écrivez quelques lignes qui comptent le nombre d’apparitions de chaque mot dans la phrase « le chat et le chien et le loup ».
Voir la réponse
Un dictionnaire est l’outil idéal :
compte = {}
for mot in "le chat et le chien et le loup".split():
compte[mot] = compte.get(mot, 0) + 1
print(compte) # {'le': 3, 'chat': 1, 'et': 2, 'chien': 1, 'loup': 1}
La méthode split() découpe la phrase en mots ; compte.get(mot, 0) renvoie le nombre déjà compté, ou 0 si le mot est nouveau. La bibliothèque standard propose aussi un outil tout fait, collections.Counter.
Exercice 4 : une compréhension de liste
Que vaut [x * x for x in [3, 4, 7, 10] if x % 2 == 0] ? Réécrivez-la avec une boucle ordinaire.
Voir la réponse
Elle garde les nombres pairs, 4 et 10, et calcule leurs carrés : [16, 100]. Version avec une boucle : resultat = [], puis for x in [3, 4, 7, 10]:, et, dans le bloc, if x % 2 == 0: resultat.append(x * x). La compréhension est plus concise, à réserver aux cas simples pour rester lisible.
Exercice 5 : le piège de la valeur par défaut
On définit def ajouter(x, liste=[]): liste.append(x); return liste. Que renvoient ajouter(1), puis ajouter(2) ? Pourquoi ? Comment corriger ?
Voir la réponse
On s’attend à [1] puis [2], mais on obtient [1] puis [1, 2]. La valeur par défaut [] est créée une seule fois, quand la fonction est définie, et non à chaque appel : tous les appels sans second paramètre partagent la même liste, qui s’allonge. La correction classique : def ajouter(x, liste=None):, puis if liste is None: liste = [] au début du corps. C’est l’un des pièges les plus connus de Python.
Exercice 6 : entiers et nombres à virgule
Pourquoi 2 ** 100 donne-t-il un résultat exact, alors que 0.1 + 0.2 == 0.3 vaut False ? Comment comparer des nombres à virgule ?
Voir la réponse
Les entiers Python ont une taille illimitée : le résultat est exact, quel que soit le nombre de chiffres. Les nombres à virgule, en revanche, sont stockés en binaire sur 64 bits, et 0,1 n’a pas d’écriture binaire finie, comme 1/3 n’a pas d’écriture décimale finie : 0,1 + 0,2 donne 0,30000000000000004. On compare donc les nombres à virgule avec une tolérance, par math.isclose(0.1 + 0.2, 0.3), et l’on utilise le module decimal pour les montants financiers, qui exigent des calculs décimaux exacts.
5Comment Python fonctionne
5.1Interprété, mais compilé d’abord
On dit couramment que Python est un langage interprété. Plus précisément, l’interpréteur de référence, CPython, écrit en C, compile d’abord le code source en un code intermédiaire (en anglais bytecode), qu’il conserve dans des fichiers .pyc d’un dossier __pycache__ pour gagner du temps la fois suivante, puis l’exécute avec sa machine virtuelle (voir les langages intermédiaires). D’autres mises en œuvre existent, comme PyPy, qui compile à la volée et accélère beaucoup certains programmes, ou MicroPython, pour les microcontrôleurs (voir les objets connectés).
5.2Les performances
Python est nettement plus lent que le C pour exécuter des boucles de calcul, souvent de plusieurs dizaines de fois : chaque opération passe par la machine virtuelle et vérifie les types pendant l’exécution. Cela compte peu pour la plupart des usages, où le temps du programmeur est plus précieux que celui de la machine, et où l’essentiel du temps se passe à attendre le réseau ou le disque. Pour les calculs intensifs, Python sert de « colle » : les bibliothèques scientifiques, comme NumPy, effectuent leurs calculs dans du code écrit en C, en Fortran ou pour les processeurs graphiques, et Python se contente de les orchestrer. Un autre frein historique est le verrou global de l’interpréteur (GIL, Global Interpreter Lock), qui empêche plusieurs fils d’exécution d’exécuter du code Python en même temps sur plusieurs cœurs ; une version sans ce verrou, expérimentale en 2024, est officiellement prise en charge depuis Python 3.14, en 2025.
5.3Pour mémoire : Python 2
On rencontre encore, dans de vieux scripts et de vieux tutoriels, du code écrit en Python 2, qui ne fonctionne pas tel quel en Python 3. Les différences les plus visibles : en Python 2, print était une instruction, print "Bonjour", et non une fonction ; la division de deux entiers donnait un entier, 7 / 2 valant 3 et non 3.5 ; et les chaînes de caractères étaient par défaut des suites d’octets, ce qui compliquait la gestion des accents et des alphabets non latins. Python 2 n’est plus maintenu depuis 2020 et ne reçoit plus de correctifs de sécurité : un programme qui en dépend encore doit être migré.