Comprendre les compréhensions de liste en Python 3

Introduction

Les compréhensions de liste offrent un moyen concis de créer des listes basées sur des listes existantes. Lorsque vous utilisez des compréhensions de liste, des listes peuvent être construites en tirant parti de n’importe quel itérable, y compris des chaînes de caractères et des tuples.

Syntaxiquement, les compréhensions de liste se composent d’un itérable contenant une expression suivie d’une clause for. Cela peut être suivi de clauses supplémentaires for ou if, donc la familiarité avec les boucles for et les déclarations conditionnelles vous aidera à mieux comprendre les compréhensions de liste.

Les compréhensions de liste fournissent une syntaxe alternative pour créer des listes et d’autres types de données séquentiels. Bien que d’autres méthodes d’itération, telles que les boucles `for`, puissent également être utilisées pour créer des listes, les compréhensions de liste peuvent être préférées car elles peuvent limiter le nombre de lignes utilisées dans votre programme.

Prérequis

Vous devriez avoir Python 3 installé et un environnement de programmation configuré sur votre ordinateur ou serveur. Si vous n’avez pas d’environnement de programmation configuré, vous pouvez vous référer aux guides d’installation et de configuration pour un environnement de programmation local ou pour un environnement de programmation sur votre serveur approprié pour votre système d’exploitation (Ubuntu, CentOS, Debian, etc.)

Compréhensions de liste

En Python, les compréhensions de liste sont construites comme ceci:

list_variable = [x for x in iterable]

A list, or other iterable, is assigned to a variable. Additional variables that stand for items within the iterable are constructed around a for clause. The in keyword is used as it is in for loops, to iterate over the iterable.

Jetons un coup d’œil à un exemple qui crée une liste basée sur une chaîne de caractères :

shark_letters = [letter for letter in 'shark']
print(shark_letters)

Ici, la nouvelle liste est assignée à la variable shark_letters, et letter est utilisé pour représenter les éléments contenus dans la chaîne itérable 'shark'.

Pour confirmer à quoi ressemble la nouvelle liste shark_letters, nous demandons son impression avec print() et recevons la sortie suivante :

Output
['s', 'h', 'a', 'r', 'k']

La liste que nous avons créée avec la compréhension de liste est composée des éléments de la chaîne 'shark', c’est-à-dire une chaîne pour chaque lettre.

Les compréhensions de liste peuvent être réécrites sous forme de boucles for, bien que toutes les boucles for ne puissent pas être réécrites sous forme de compréhension de liste.

En utilisant notre compréhension de liste qui a créé la liste shark_letters ci-dessus, réécrivons-la comme une boucle for. Cela peut nous aider à mieux comprendre le fonctionnement de la compréhension de liste.

shark_letters = []

for letter in 'shark':
    shark_letters.append(letter)

print(shark_letters)

Lors de la création d’une liste avec une boucle for, la variable attribuée à la liste doit être initialisée avec une liste vide, comme c’est le cas dans la première ligne de notre bloc de code. La boucle for itère ensuite sur l’élément, en utilisant la variable letter dans la chaîne itérable 'shark'. À l’intérieur de la boucle for, chaque élément de la chaîne est ajouté à la liste avec la méthode list.append(x).

La réécriture de la compréhension de liste sous forme de boucle for nous donne le même résultat :

Output
['s', 'h', 'a', 'r', 'k']

Les compréhensions de liste peuvent être réécrites en boucles for, et certaines boucles for peuvent être réécrites sous forme de compréhensions de liste pour rendre le code plus concis.

Utilisation de conditionnelles avec les compréhensions de liste

Les compréhensions de liste peuvent utiliser des instructions conditionnelles pour modifier des listes existantes ou d’autres types de données séquentiels lors de la création de nouvelles listes.

Examinons un exemple d’utilisation d’une instruction if dans une compréhension de liste :

fish_tuple = ('blowfish', 'clownfish', 'catfish', 'octopus')

fish_list = [fish for fish in fish_tuple if fish != 'octopus']
print(fish_list)

La compréhension de liste utilise le tuple fish_tuple comme base pour la nouvelle liste appelée fish_list. Les mots-clés for et in sont utilisés, comme dans la section ci-dessus, et maintenant une instruction if est ajoutée. L’instruction if indique d’ajouter uniquement les éléments qui ne sont pas équivalents à la chaîne 'octopus', donc la nouvelle liste ne prend en compte que les éléments du tuple qui ne correspondent pas à 'octopus'.

Lorsque nous exécutons cela, nous remarquerons que fish_list contient les mêmes éléments de chaîne que fish_tuple à l’exception du fait que la chaîne 'octopus' a été omise :

Output
['blowfish', 'clownfish', 'catfish']

Notre nouvelle liste contient donc chaque élément du tuple d’origine à l’exception de la chaîne qui est exclue par l’instruction conditionnelle.

Nous allons créer un autre exemple qui utilise des opérateurs mathématiques, des entiers, et le type de séquence range().

number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)

La liste qui est créée, number_list, sera peuplée avec les valeurs au carré de chaque élément dans la plage de 0 à 9 si la valeur de l’élément est divisible par 2. La sortie est la suivante:

Output
[0, 4, 16, 36, 64]

Pour décomposer un peu plus ce que fait la compréhension de liste, réfléchissons à ce qui serait imprimé si nous ne faisions qu’appeler x for x in range(10). Notre petit programme et sa sortie ressembleraient alors à ce qui suit:

number_list = [x for x in range(10)]
print(number_list)

Output
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Maintenant, ajoutons l’instruction conditionnelle:

number_list = [x for x in range(10) if x % 2 == 0]
print(number_list)

Output
[0, 2, 4, 6, 8]

L’instruction if a limité les éléments dans la liste finale pour inclure uniquement ceux qui sont divisibles par 2, en omettant tous les nombres impairs.

Enfin, nous pouvons ajouter l’opérateur pour élever chaque x au carré:

number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)

Ainsi, chacun des nombres de la liste précédente [0, 2, 4, 6, 8] est maintenant élevé au carré:

Output
[0, 4, 16, 36, 64]

Vous pouvez également reproduire des instructions conditionnelles imbriquées avec une compréhension de liste:

number_list = [x for x in range(100) if x % 3 == 0 if x % 5 == 0]
print(number_list)

Ici, la compréhension de liste vérifiera d’abord si le nombre x est divisible par 3, puis vérifiera si x est divisible par 5. Si x satisfait aux deux conditions, il sera imprimé, et la sortie est:

Output
[0, 15, 30, 45, 60, 75, 90]

Les instructions conditionnelles if peuvent être utilisées pour contrôler quels éléments d’une séquence existante sont inclus dans la création d’une nouvelle liste.

Boucles imbriquées dans une compréhension de liste

Les boucles imbriquées peuvent être utilisées pour effectuer de multiples itérations dans nos programmes.

Cette fois, nous allons examiner une construction de boucle for imbriquée existante et progresser vers une compréhension de liste.

Notre code va créer une nouvelle liste qui itère sur 2 listes et effectue des opérations mathématiques basées sur elles. Voici notre bloc de code de boucle for imbriquée:

my_list = []

for x in [20, 40, 60]:
	for y in [2, 4, 6]:
		my_list.append(x * y)

print(my_list)

Quand nous exécutons ce code, nous obtenons la sortie suivante:

Output
[40, 80, 120, 80, 160, 240, 120, 240, 360]

Ce code multiplie les éléments de la première liste par les éléments de la deuxième liste à chaque itération.

Pour transformer cela en une compréhension de liste, nous allons condenser chacune des lignes de code en une seule ligne, en commençant par l’opération x * y. Cela sera suivi par la boucle for externe, puis la boucle for interne. Nous ajouterons une instruction print() en dessous de notre compréhension de liste pour confirmer que la nouvelle liste correspond à la liste que nous avons créée avec notre bloc de boucle for imbriquée ci-dessus:

my_list = [x * y for x in [20, 40, 60] for y in [2, 4, 6]]
print(my_list)

Output
[40, 80, 120, 80, 160, 240, 120, 240, 360]

Notre compréhension de liste prend les boucles for imbriquées et les aplatisse en une seule ligne de code tout en créant exactement la même liste à assigner à la variable my_list.

Les compréhensions de liste nous fournissent une manière concise de créer des listes, nous permettant de réduire plusieurs lignes de code en une seule ligne. Cependant, il est important de garder à l’esprit que la lisibilité de notre code doit toujours primer, donc lorsque qu’une ligne de compréhension de liste devient trop longue ou difficile à manipuler, il peut être préférable de la diviser en boucles.

Conclusion

Les compréhensions de liste nous permettent de transformer une liste ou une autre séquence en une nouvelle liste. Elles offrent une syntaxe concise pour accomplir cette tâche, limitant nos lignes de code.

Les compréhensions de liste suivent la forme mathématique de la notation ensembliste ou de la compréhension d’ensemble, ce qui peut être particulièrement intuitif pour les programmeurs ayant une formation mathématique.

Bien que les compréhensions de liste puissent rendre notre code plus succinct, il est important de s’assurer que notre code final soit aussi lisible que possible, donc de très longues lignes de code doivent être évitées pour garantir que notre code soit convivial.