Maîtrisez les compréhensions de liste en Python : utilisation et bonnes pratiques

Vous avez peut-être déjà entendu parler des compréhensions de liste en Python, ou même utilisé sans en saisir pleinement le potentiel. Il est temps de tout maîtriser : ce guide complet couvre tout ce qu'il faut savoir pour les exploiter efficacement.

Avant de plonger dans le vif du sujet, rappelez-vous les bases des listes en Python et l'utilisation des dictionnaires pour contextualiser.

Qu'est-ce qu'une compréhension de liste en Python ?

Les compréhensions de liste paraissent complexes au premier abord, mais elles sont en réalité simples. En Python, elles offrent un moyen concis de filtrer ou transformer une liste selon des critères précis.

Elles évitent d'écrire plusieurs lignes de code, surtout dans une boucle, tout en préservant la lisibilité. Attention toutefois : elles ne conviennent pas toujours. Évitez les versions trop complexes qui nuisent à la lecture. Privilégiez la simplicité et le principe d'une seule responsabilité par code.

Comment utiliser les compréhensions de liste en Python

Note : Tous les exemples ci-dessous utilisent Python 3.6+. Consultez notre FAQ Python pour les différences avec Python 2.

Considérez ce code qui copie une liste et convertit chaque lettre en majuscule via une boucle :

lettres = ['a', 'b', 'c', 'd']
print(lettres)
lettres_majuscules = []
for lettre in lettres:
    resultat = lettre.upper()
    lettres_majuscules.append(resultat)
print(lettres_majuscules)

Voici la même logique en une ligne avec une compréhension de liste basique :

lettres = ['a', 'b', 'c', 'd']
print(lettres)
lettres_majuscules = [x.upper() for x in lettres]
print(lettres_majuscules)

Le résultat est identique, mais bien plus concis.

Décomposons : on crée lettres avec des minuscules. Sans compréhension, il faut une nouvelle liste lettres_majuscules, boucler, convertir et ajouter. Fatigant !

La compréhension dit : « Pour chaque x dans lettres, applique upper() et forme une nouvelle liste. »

Elle ne s'applique qu'aux listes et renvoie toujours une liste. Examinons ses trois parties (la troisième plus bas).

Encadrez par des crochets [ ]. D'abord, l'expression de transformation :

[x.upper()  # incomplet

Puis, la boucle : for x in lettres.

Ensemble : lettres_majuscules = [x.upper() for x in lettres].

La troisième partie : la condition

Optionnelle, elle filtre comme un if : « Nouvelle liste avec éléments satisfaisant le critère. »

ages = [1, 34, 5, 7, 3, 57, 356]
print(ages)
ages_adultes = [x for x in ages if x > 10]
print(ages_adultes)

Ici, seuls les âges > 10 sont retenus.

Quand éviter les compréhensions de liste

Elles brillent pour les cas simples, mais pas pour plusieurs conditions :

ages_adultes = [x for x in ages if x > 10 and x < 100 and x is not None]

Trop long ? Préférez une boucle. Évitez aussi les fonctions complexes ou erreurs potentielles :

lettres = ['a', 'b', 'c', 'd', 2]
print(lettres)
lettres_majuscules = [x.upper() for x in lettres]  # Erreur !

Une boucle gère les exceptions :

lettres = ['a', 'b', 'c', 'd', 1]
print(lettres)
lettres_majuscules = []
for lettre in lettres:
    try:
        resultat = lettre.upper()
        lettres_majuscules.append(resultat)
    except AttributeError:
        pass  # Ignorer
print(lettres_majuscules)

Mettez-les en pratique

Simples et puissantes, priorisez lisibilité. Essayez avec un Arduino via Python ou une caméra de sécurité DIY !