introduction
List comprehensions offre un moyen succinct de créer deslists à partir de listes existantes. Lors de l'utilisation de la compréhension de liste, les listes peuvent être construites en exploitant n'importe queliterable, y comprisstrings ettuples.
Syntaxiquement, les compréhensions de liste consistent en un itérable contenant une expression suivie d'une clausefor. Cela peut être suivi par des clausesfor ouif supplémentaires, donc la familiarité avecfor loops etconditional statements vous aidera à mieux comprendre la compréhension des listes.
Les compréhensions de listes fournissent une syntaxe alternative à la création de listes et d'autresdata typeséquentiels. Alors que d'autres méthodes d'itération, telles que les bouclesfor, peuvent également être utilisées pour créer des listes, les compréhensions de listes peuvent être préférées car elles peuvent limiter le nombre de lignes utilisées dans votre programme.
Liste des compréhensions
En Python, les compréhensions de liste sont construites comme suit:
list_variable = [x for x in iterable]Une liste, ou une autre variable, est assignée à une variable. Les variables supplémentaires qui représentent les éléments dans l'itérable sont construites autour d'une clausefor. Le mot cléin est utilisé tel quel dans les bouclesfor, pour itérer sur lesiterable.
Regardons un exemple qui crée une liste basée sur une chaîne:
shark_letters = [letter for letter in 'shark']
print(shark_letters)Ici, la nouvelle liste est affectée à la variableshark_letters, etletter est utilisé pour remplacer les éléments contenus dans la chaîne itérable'shark'.
Pour que nous puissions confirmer à quoi ressemble la nouvelle listeshark_letters, nous l'appelons à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 comme des bouclesfor, bien que toutes les bouclesfor ne puissent pas être réécrites comme une compréhension de liste.
En utilisant notre compréhension de liste qui a créé la listeshark_letters ci-dessus, réécrivons-la comme une bouclefor. Cela peut nous aider à mieux comprendre le fonctionnement de la compréhension de la liste.
shark_letters = []
for letter in 'shark':
shark_letters.append(letter)
print(shark_letters)Lors de la création d'une liste avec une bouclefor, la variable affecté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 bouclefor itère ensuite sur l'élément, en utilisant la variableletter dans la chaîne itérable'shark'. Dans la bouclefor, chaque élément de la chaîne estadded to the list with the list.append(x) method.
La réécriture de la compréhension de la liste comme une bouclefor nous fournit le même résultat:
Output['s', 'h', 'a', 'r', 'k']Les compréhensions de listes peuvent être réécrites comme des bouclesfor, et certaines bouclesfor peuvent être réécrites pour être des compréhensions de listes pour rendre le code plus succinct.
Utilisation de conditions avec des compositions de liste
La compréhension des listes peut 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.
Regardons un exemple d'instructionif 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 tuplefish_tuple comme base pour la nouvelle liste appeléefish_list. Les mots-clés defor etin sont utilisés, comme ils l'étaient dans lessection above, et maintenant une instructionif est ajoutée. L'instructionif dit d'ajouter uniquement les éléments qui ne sont pas équivalents à la chaîne'octopus', de sorte que la nouvelle liste ne prend que les éléments du tuple qui ne correspondent pas à'octopus'.
Lorsque nous exécutons ceci, nous verrons quefish_list contient les mêmes éléments de chaîne quefish_tuple, à l'exception du fait que la chaîne'octopus' a été omise:
Output['blowfish', 'clownfish', 'catfish']Notre nouvelle liste contient donc tous les éléments du tuple d'origine, à l'exception de la chaîne exclue par l'instruction conditionnelle.
Nous allons créer un autre exemple utilisantmathematical operators,integers et lesrange() sequence type.
number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)La liste en cours de création,number_list, sera remplie avec les valeurs au carré de chaque élément dans la plage de 0 à 9if 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 appelions simplementx for x in range(10). Notre petit programme et notre résultat ressembleraient alors à ceci:
number_list = [x for x in range(10)]
print(number_list)Output[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]Ajoutons maintenant l’énoncé conditionnel:
number_list = [x for x in range(10) if x % 2 == 0]
print(number_list)Output[0, 2, 4, 6, 8]L'instructionif a limité les éléments de la liste finale pour inclure uniquement les éléments divisibles par 2, en omettant tous les nombres impairs.
Enfin, nous pouvons ajouter l'opérateur pour avoir chaquex 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é:
Output[0, 4, 16, 36, 64]Vous pouvez également répliquernested if statements 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 la liste vérifie d'abord si le nombrex est divisible par 3, puis vérifie six est divisible par 5. Six satisfait aux deux exigences, il imprimera et la sortie sera:
Output[0, 15, 30, 45, 60, 75, 90]Les instructions conditionnellesif 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
Nested loops peut être utilisé pour effectuer plusieurs itérations dans nos programmes.
Cette fois, nous allons examiner une construction de bouclefor 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 celles-ci. Voici notre bloc de code de boucle imbriquéfor:
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 le résultat suivant:
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érationx * y. Ceci sera suivi de la boucle externefor, puis de la boucle internefor. Nous ajouterons une instructionprint() sous notre compréhension de liste pour confirmer que la nouvelle liste correspond à la liste que nous avons créée avec notre bloc de bouclefor imbriqué 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 imbriquéesfor et les aplatit en une seule ligne de code tout en créant exactement la même liste à affecter à la variablemy_list.
La compréhension des listes nous fournit un moyen succinct de créer des listes, nous permettant de distiller plusieurs lignes de code en une seule ligne. Cependant, il convient de garder à l'esprit que la lisibilité de notre code doit toujours prévaloir. Ainsi, lorsqu'une ligne de compréhension de liste devient trop longue ou trop lourde, il peut être préférable de la diviser en boucles.
Conclusion
La compréhension des listes nous permet de transformer une liste ou une autre séquence en une nouvelle liste. Ils fournissent une syntaxe concise pour effectuer cette tâche, en limitant nos lignes de code.
La compréhension de liste suit la forme mathématique de la notation de constructeur d’ensembles ou de compréhension d’ensemble, de sorte qu’elle peut être particulièrement intuitive pour les programmeurs ayant une formation en mathématiques.
Bien que la compréhension des listes puisse rendre notre code plus succinct, il est important de veiller à ce que notre code final soit aussi lisible que possible. Par conséquent, vous devez éviter les très longues lignes de code afin de rendre notre code convivial.