Comprendre les compréhensions de listes en Python 3

Introduction

Les compréhensions de liste offrent un moyen succinct de créer des listes à partir de listes existantes. Lors de l'utilisation des compréhensions de liste, des listes peuvent être construites en s'appuyant sur tout itérable, y compris les chaînes de caractères et les tuples.

Sur le plan syntaxique, les compréhensions de listes se composent d'un itérable contenant une expression suivie d'une clause for. Cela peut être suivi de clauses for ou if supplémentaires, donc la familiarité avec les boucles for et les instructions conditionnelles vous aidera à mieux comprendre les compréhensions de listes.

Les compréhensions de liste offrent 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.

Conditions préalables

Vous devez 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 consulter les guides d'installation et de configuration pour un environnement de programmation local ou pour un environnement de programmation sur votre serveur, approprié à votre système d'exploitation (Ubuntu, CentOS, Debian, etc.).

Compréhensions de listes

En Python, les compréhensions de listes se construisent comme ceci :

list_variable = [x for x in iterable]

Une liste, ou un autre itérable, est assignée à une variable. Des variables supplémentaires qui représentent des éléments au sein de l'itérable sont construites autour d'une clause for. Le mot-clé in est utilisé comme dans les boucles for, pour itérer sur l'itérable.

Regardons un exemple qui crée une liste à partir d'une chaîne :

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 que nous puissions confirmer à quoi ressemble la nouvelle liste shark_letters, nous l'appelons avec print() et recevons la sortie suivante :

['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 en tant que compréhensions de liste.

En utilisant notre compréhension de liste qui a créé la liste shark_letters ci-dessus, réécrivons-la sous forme de boucle for. Cela peut nous aider à mieux comprendre comment fonctionne 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 assigné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'item, en utilisant la variable letter dans la chaîne itérable 'shark'. À l'intérieur de la boucle for, chaque item de la chaîne est ajouté à la liste avec la méthode list.append(x).

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

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

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

Utiliser des conditionnels avec des compréhensions de listes

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

Regardons un exemple d'une instruction if utilisée 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, sauf que la chaîne 'octopus' a été omise :

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

Notre nouvelle liste a donc chaque élément de l'original tuple sauf pour la chaîne qui est exclue par la déclaration conditionnelle.

Nous créerons 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 en cours de création, number_list, sera remplie avec les valeurs carrées de chaque élément dans la plage de 0 à 9 si la valeur de l'élément est divisible par 2. Le résultat est le suivant :

[0, 4, 16, 36, 64]

Pour décomposer ce que fait la compréhension de liste un peu plus, pensons à ce qui serait imprimé si nous n'appelions que 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)

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

Maintenant, ajoutons la déclaration conditionnelle :

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

[0, 2, 4, 6, 8]

L'instruction if a limité les éléments de la liste finale pour n'inclure que ceux qui sont divisibles par 2, omettant tous les nombres impairs.

Enfin, nous pouvons ajouter l'opérateur pour que chaque x soit 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 de [0, 2, 4, 6, 8] est maintenant au carré :

[0, 4, 16, 36, 64]

Vous pouvez également reproduire des instructions if 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 les deux conditions, il sera imprimé, et la sortie est :

[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 plusieurs itérations dans nos programmes.

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

Notre code créera une nouvelle liste qui itère sur 2 listes et effectue des opérations mathématiques en fonction de celles-ci. Voici notre bloc de code avec une 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)

Lorsque nous exécutons ce code, nous recevons la sortie suivante :

[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 seconde liste à chaque itération.

Pour transformer cela en 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 de la boucle for externe, puis de 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)

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

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

Les compréhensions de listes nous offrent une manière succincte de créer des listes, nous permettant de distiller 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 la ligne de compréhensions de listes devient trop longue ou difficile à gérer, il peut être préférable de la transformer 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 le nombre de lignes de code.

Les compréhensions de listes suivent la forme mathématique de la notation de construction d'ensemble ou de compréhension d'ensemble, elles peuvent donc être particulièrement intuitives pour les programmeurs ayant une formation mathématique.

Bien que les compréhensions de liste puissent rendre notre code plus concis, il est important de s'assurer que notre code final soit aussi lisible que possible, donc il faut éviter les lignes de code très longues pour garantir que notre code soit convivial.