Introduction
Créer des tableaux de manière efficace est une compétence essentielle en informatique. Python permet d’y parvenir grâce aux compréhensions, une syntaxe concise qui permet de générer, transformer ou filtrer des tableaux en une seule ligne. Cette méthode s’avère particulièrement utile pour le traitement de données, la transformation de structures complexes ou encore la création de matrices. En apprenant à manier les compréhensions, on développe une pensée algorithmique rigoureuse et on gagne en clarté dans l’écriture des programmes.
Comprendre la compréhension de liste
La compréhension de liste est une manière condensée de créer une nouvelle liste à partir d’une expression appliquée à chaque élément d’un itérable. Cette syntaxe évite d’écrire une boucle classique et rend le code plus direct.
Forme de base :
nouvelle_liste = [expression for élément in itérable]
Avec condition :
nouvelle_liste = [expression for élément in itérable if condition]
Exemples :
Créer un tableau contenant les carrés des entiers de 0 à 9 :
carres = [x**2 for x in range(10)]
Extraire les entiers pairs de 0 à 19 :
pairs = [x for x in range(20) if x % 2 == 0]
Transformer les mots d’une phrase en majuscules :
mots = "le code python est simple".split()
majuscules = [mot.upper() for mot in mots]
Ces formes simples couvrent déjà de nombreux usages courants en traitement de données ou en affichage.
À retenir
La compréhension de liste permet de générer un tableau en appliquant une transformation à chaque élément, avec une éventuelle condition de filtrage. Elle remplace avantageusement les boucles classiques.
Aller plus loin : conditions et compréhensions imbriquées
Les compréhensions ne se limitent pas à une transformation directe. On peut y intégrer des conditions if/else ou imbriquer plusieurs boucles pour parcourir des structures plus complexes.
Exemple avec condition if/else :
Remplacer les entiers pairs par leur double, et les impairs par zéro :
nombres = [1, 2, 3, 4]
résultat = [x*2 if x % 2 == 0 else 0 for x in nombres]
Résultat : [0, 4, 0, 8]
Exemple avec double boucle pour créer une table de multiplication :
produits = [(i, j, i*j) for i in range(1, 4) for j in range(1, 4)]
Cet exemple génère un tableau contenant tous les produits possibles de deux entiers entre 1 et 3. Il illustre aussi la création de matrices.
Lien explicite avec les matrices :
Une matrice peut être représentée comme un tableau de tableaux, c’est-à-dire une liste dont chaque élément est lui-même une liste. Exemple :
matrice = [[i*j for j in range(1, 6)] for i in range(1, 6)]
À retenir
Les compréhensions peuvent inclure plusieurs niveaux de boucles ou des conditions complexes. Elles permettent de modéliser des structures comme les matrices et de transformer des données de manière expressive.
Appliquer les compréhensions aux structures complexes
La compréhension de liste est particulièrement utile lorsqu’il s’agit de manipuler des structures de données plus complexes, comme des fichiers, des dictionnaires ou des listes de listes.
Aplatir une matrice :
matrice = [[1, 2], [3, 4], [5, 6]]
aplatie = [x for ligne in matrice for x in ligne]
Résultat : [1, 2, 3, 4, 5, 6]
Extraire des champs spécifiques d’un tableau de dictionnaires :
personnes = [{"prenom": "Alice"}, {"prenom": "Bob"}, {"prenom": "Chloé"}]
prenoms = [personne["prenom"] for personne in personnes]
Exemple avec un fichier CSV (traitement de données réel) :
Soit un fichier eleves.csv contenant :
nom,prenom,note
Dupont,Alice,15
Martin,Bob,12
Durand,Chloé,17
Chargement et extraction des prénoms avec une compréhension :
with open("eleves.csv") as f:
lignes = f.readlines()[1:] # On saute l’en-tête
prenoms = [ligne.strip().split(",")[1] for ligne in lignes]
On récupère ainsi rapidement les prénoms de tous les élèves du fichier, sans boucle explicite.
À retenir
Les compréhensions permettent de manipuler facilement des structures complexes comme des dictionnaires, des matrices ou des fichiers. Elles facilitent le traitement de données structurées issues du monde réel.
La compréhension de dictionnaire
Moins connue, la compréhension de dictionnaire suit le même principe mais construit des paires clé : valeur. Elle s’avère précieuse lorsqu’on souhaite transformer une table de correspondances ou indexer des données.
Syntaxe générale :
dico = {clé: valeur for élément in itérable}
Exemple : créer un dictionnaire qui associe à chaque entier son carré :
carres = {x: x**2 for x in range(5)}
Résultat : {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
Exemple avec condition :
nombres_pairs = {x: x**2 for x in range(10) if x % 2 == 0}
Les compréhensions de dictionnaire sont utiles pour restructurer des données ou effectuer des recherches rapides par clé.
À retenir
Comme les listes, les dictionnaires peuvent être construits de façon concise grâce aux compréhensions. Cette méthode permet de créer des structures associatives dynamiques à partir de données existantes.
Conclusion
La compréhension de liste est une technique puissante qui permet de créer rapidement des tableaux en Python. Elle favorise une écriture concise, expressive et souvent plus performante. En allant au-delà des cas simples, on peut transformer des structures complexes, manipuler des fichiers, modéliser des matrices et même générer des dictionnaires. Ces compétences sont essentielles pour gagner en autonomie dans l’analyse et le traitement des données, et constituent une base solide pour aborder des notions plus avancées en Terminale.