Introduction
Dans ce laboratoire, vous serez initié aux compréhensions Python (Python comprehensions), une syntaxe spéciale qui vous permet de créer des structures de données telles que des listes, des ensembles (sets) et des dictionnaires à partir d'autres itérables de manière très concise. Les compréhensions sont incroyablement utiles lorsque vous traitez un ou deux niveaux de boucles for imbriquées, rendant votre code plus lisible et souvent plus efficace.
Vous commencerez par le type le plus courant, les compréhensions de liste (list comprehensions), et verrez comment elles se comparent aux boucles for traditionnelles. Ensuite, vous apprendrez à ajouter une logique conditionnelle pour filtrer ou transformer des éléments. Enfin, vous verrez comment les mêmes principes s'appliquent à la création d'ensembles et de dictionnaires.
Compréhension de liste
Dans cette étape, vous apprendrez la syntaxe de base des compréhensions de liste comme moyen concis de créer des listes à partir d'autres itérables. Nous comparerons l'approche traditionnelle avec la boucle for à la syntaxe plus élégante de la compréhension de liste.
Note: Si vous n'êtes pas familier avec l'utilisation de WebIDE (similaire à VS Code), veuillez d'abord vous familiariser avec celui-ci dans ce laboratoire.
Tout d'abord, examinons comment nous créerions une nouvelle liste à partir d'une liste existante en utilisant une boucle for standard.
Ouvrez le fichier main.py dans l'explorateur de fichiers à gauche. Copiez et collez le code suivant dans le fichier :
## Approche traditionnelle : créer une liste en utilisant une boucle for
names = ['Charles', 'Susan', 'Patrick', 'George']
new_list = []
for n in names:
new_list.append(n)
print(new_list)
Pour exécuter le code, ouvrez un terminal en cliquant sur l'icône + dans le panneau du terminal et en sélectionnant "New Terminal". Ensuite, exécutez la commande suivante :
python3 main.py
Vous verrez la sortie suivante :
['Charles', 'Susan', 'Patrick', 'George']
Maintenant, obtenons le même résultat en utilisant une compréhension de liste. La syntaxe de base est [expression for item in iterable].
Remplacez le contenu de main.py par le code suivant :
## Compréhension de liste : manière concise de créer une nouvelle liste
## Syntaxe : [expression for item in iterable]
names = ['Charles', 'Susan', 'Patrick', 'George']
new_list = [n for n in names] ## Créer une liste avec tous les noms
print(new_list)
Exécutez à nouveau le script :
python3 main.py
La sortie est identique, mais le code est beaucoup plus court et plus descriptif.
['Charles', 'Susan', 'Patrick', 'George']
Les compréhensions de liste peuvent également gérer des boucles imbriquées (nested loops). Par exemple, pour créer une liste de tuples à partir de deux plages (ranges), vous pouvez procéder comme suit.
Mettez à jour votre fichier main.py avec ce code et exécutez-le.
## Compréhension de liste imbriquée : créer des tuples à partir de deux plages
## Équivalent à des boucles for imbriquées
n = [(a, b) for a in range(1, 3) for b in range(1, 3)]
print(n)
Exécutez le script :
python3 main.py
La sortie sera une liste de toutes les combinaisons de tuples possibles :
[(1, 1), (1, 2), (2, 1), (2, 2)]
Ajout de conditions
Dans cette étape, vous explorerez comment intégrer une logique conditionnelle dans les compréhensions de liste. Vous apprendrez à filtrer des éléments en utilisant une instruction if et comment appliquer des expressions conditionnelles à chaque élément en utilisant une structure if-else.
Supposons que nous voulions créer une nouvelle liste contenant uniquement les noms qui commencent par la lettre 'C'. Avec une boucle for traditionnelle, vous ajouteriez une instruction if à l'intérieur de la boucle.
Mettez à jour votre main.py avec le code suivant :
## Traditional approach: filter with if condition
names = ['Charles', 'Susan', 'Patrick', 'George', 'Carol']
new_list = []
for n in names:
if n.startswith('C'): ## Filter names starting with 'C'
new_list.append(n)
print(new_list)
Exécutez le script pour voir le résultat :
python3 main.py
Sortie :
['Charles', 'Carol']
Pour faire cela avec une compréhension de liste, vous ajoutez l'instruction if à la fin. La syntaxe est [expression for item in iterable if condition].
Essayez ceci dans votre main.py :
## List comprehension with condition: filter items
## Syntax: [expression for item in iterable if condition]
names = ['Charles', 'Susan', 'Patrick', 'George', 'Carol']
new_list = [n for n in names if n.startswith('C')]
print(new_list)
Exécutez-le, et vous obtiendrez la même liste filtrée :
python3 main.py
Sortie :
['Charles', 'Carol']
Vous pouvez également utiliser une instruction if-else pour effectuer une action conditionnelle sur chaque élément. Dans ce cas, l'expression if-else vient avant la boucle for. La syntaxe est [expression_if_true if condition else expression_if_false for item in iterable].
Créons une nouvelle liste qui double les nombres pairs tout en conservant les nombres impairs tels quels. Mettez à jour main.py avec le code suivant et exécutez-le.
## List comprehension with if-else: conditional expression
## Syntax: [expression_if_true if condition else expression_if_false for item in iterable]
nums = [1, 2, 3, 4, 5, 6]
new_list = [num*2 if num % 2 == 0 else num for num in nums] ## Double even numbers
print(new_list)
Exécutez le script :
python3 main.py
La sortie montre que seuls les nombres pairs ont été doublés :
[1, 4, 3, 8, 5, 12]
Compréhension d'ensemble (Set comprehension)
Dans cette étape, vous comprendrez comment appliquer la syntaxe de compréhension pour créer des ensembles (sets). Les bases des compréhensions de list s'appliquent également aux ensembles (sets) et aux dictionnaires.
Les compréhensions d'ensemble sont très similaires aux compréhensions de liste. La principale différence est qu'elles utilisent des accolades {} au lieu de crochets [] et produisent un ensemble, qui est une collection non ordonnée d'éléments uniques.
La syntaxe est {expression for item in iterable}.
Créons un ensemble à partir d'un autre ensemble, en convertissant tous ses éléments de type chaîne (string) en majuscules. Mettez à jour votre fichier main.py avec le code suivant :
## Set comprehension: create a set using comprehension syntax
## Syntax: {expression for item in iterable}
b = {"abc", "def"}
upper_set = {s.upper() for s in b} ## Convert all strings to uppercase
print(upper_set)
Maintenant, exécutez le script :
python3 main.py
La sortie sera un nouvel ensemble contenant les chaînes en majuscules. Notez que puisque les ensembles ne sont pas ordonnés, l'ordre des éléments dans la sortie peut varier.
{'DEF', 'ABC'}
Si l'itérable d'origine contenait des éléments dupliqués, l'ensemble résultant ne contiendrait que les éléments uniques, car les ensembles suppriment automatiquement les doublons.
Compréhension de dictionnaire (Dict comprehension)
Dans cette étape, vous apprendrez à construire des dictionnaires en utilisant les compréhensions de dictionnaire. Comme les compréhensions d'ensemble, elles utilisent également des accolades {}, mais elles nécessitent une paire clé-valeur séparée par deux points.
La syntaxe est {key_expression: value_expression for item in iterable}.
Un cas d'utilisation courant est de créer un nouveau dictionnaire en transformant ou en inversant les paires clé-valeur d'un dictionnaire existant. Essayons d'inverser les clés et les valeurs d'un dictionnaire.
Mettez à jour votre fichier main.py avec le code suivant :
## Dict comprehension: swap keys and values
## Syntax: {key_expression: value_expression for item in iterable}
c = {'name': 'Pooka', 'age': 5}
swapped_dict = {v: k for k, v in c.items()} ## Reverse key-value pairs
print(swapped_dict)
Exécutez le script :
python3 main.py
La sortie sera un nouveau dictionnaire où les valeurs d'origine sont maintenant les clés, et les clés d'origine sont les valeurs.
{'Pooka': 'name', 5: 'age'}
Vous pouvez également utiliser des compréhensions pour créer d'autres types de données à partir de dictionnaires. Par exemple, voici comment vous pouvez utiliser une compréhension de liste pour générer une liste de chaînes formatées à partir des éléments d'un dictionnaire.
Remplacez le code dans main.py par cet exemple et exécutez-le :
## List comprehension from dictionary: create formatted strings
c = {'name': 'Pooka', 'age': 5}
formatted_list = ["{}:{}".format(k.upper(), v) for k, v in c.items()] ## Format as "KEY:value"
print(formatted_list)
Exécutez le script :
python3 main.py
Ceci produira une liste de chaînes, et non un dictionnaire.
['NAME:Pooka', 'AGE:5']
Ceci démontre la flexibilité d'utiliser des compréhensions pour traiter et transformer différentes structures de données. Pour votre tâche finale dans cette étape, veuillez vous assurer que votre main.py contient le code d'inversion de dictionnaire.
Résumé
Dans ce laboratoire, vous avez appris à utiliser la syntaxe de compréhension puissante de Python pour créer des listes, des ensembles (sets) et des dictionnaires d'une manière concise et lisible.
Vous avez commencé par les compréhensions de liste, en voyant comment elles offrent une alternative plus élégante aux boucles for traditionnelles. Vous avez ensuite appris à ajouter une logique conditionnelle, en utilisant un if final pour le filtrage et une expression if-else pour la transformation des éléments. Enfin, vous avez vu comment ces mêmes principes s'appliquent aux compréhensions d'ensemble et de dictionnaire, en utilisant des accolades {} pour construire des ensembles d'éléments uniques et des dictionnaires de paires clé-valeur.
Les compréhensions sont une partie fondamentale du code Python idiomatique. Les maîtriser rendra votre code plus efficace et élégant. Continuez à vous entraîner pour qu'elles deviennent une partie naturelle de votre boîte à outils de programmation Python.
