Tutoriel de compréhension de listes en Python

Dans le cadre de la science des données, vous pouvez être amené à lire des listes de listes, à filtrer des noms de colonnes, à supprimer les voyelles d'une liste ou à aplatir une matrice. Vous pouvez facilement utiliser une fonction lambda ou une boucle for ; comme vous le savez, il y a plusieurs façons de procéder. Une autre façon d'y parvenir est d'utiliser des listes de compréhension.

Ce tutoriel aborde ce dernier point :

• Vous commencerez par un bref rappel de ce que sont les listes Python et de leur comparaison avec d'autres structures de données Python ;
• Ensuite, vous plongerez dans les compréhensions de listes Python : vous en apprendrez plus sur les mathématiques derrière les listes Python, comment vous pouvez construire des compréhensions de listes, comment vous pouvez les réécrire comme des boucles for ou des fonctions lambda, ..... Vous ne ferez pas que lire, mais vous ferez aussi des exercices !
• Lorsque vous aurez acquis les bases, il sera également temps d'affiner vos compréhensions de listes en y ajoutant des conditionnalités : vous apprendrez comment inclure des conditionnalités dans les compréhensions de listes et comment gérer des conditions if et des instructions if-else multiples.
• Enfin, vous plongerez dans les compréhensions de listes imbriquées pour itérer plusieurs fois sur des listes.

Si vous êtes également intéressé par les compréhensions de listes, les itérateurs et les générateurs ? Découvrez le cours Python Data Science Toolbox de DataCamp !

Listes Python

Jusqu'à présent, vous avez probablement joué avec des valeurs ayant plusieurs types de données. Vous avez enregistré chaque valeur dans une variable distincte : chaque variable représente une seule valeur. Cependant, en science des données, vous travaillerez souvent avec de nombreux points de données, ce qui rendra difficile le stockage de chaque valeur dans une variable distincte. Au lieu de cela, vous stockez toutes ces valeurs dans une liste Python.

Les listes sont l'une des quatre structures de données intégrées à Python. Les autres structures de données que vous connaissez peut-être sont les tuples, les dictionnaires et les ensembles. En Python, une liste est différente de int ou bool, par exemple, en ce sens qu'il s'agit d'un type de données composé : vous pouvez regrouper des valeurs dans des listes. En fait, ces valeurs ne doivent pas nécessairement être du même type : il peut s'agir d'une combinaison de valeurs booléennes, de chaînes de caractères, d'entiers, etc.

Il est important de noter que les listes sont des collections ordonnées d'éléments ou d'objets. Cela fait des listes en Python des "types de séquence", car elles se comportent comme une séquence. Cela signifie qu'elles peuvent être itérées. D'autres exemples de séquences sont les chaînes de caractères, les tuples ou les ensembles.

Astuce: si vous souhaitez en savoir plus, tester ou mettre en pratique vos connaissances sur les listes Python, vous pouvez le faire en parcourant les questions les plus courantes sur les listes Python ici.

Maintenant, d'un point de vue pratique : vous construisez une liste avec deux crochets ; à l'intérieur de ces crochets, vous utiliserez des virgules pour séparer vos valeurs. Vous pouvez ensuite assigner votre liste à une variable. Les valeurs que vous placez dans une liste Python peuvent être de n'importe quel type de données, même des listes !

Examinez l'exemple de liste suivant :

Astuce: construisez votre propre liste dans le shell IPython qui est contenu dans le morceau de DataCamp Light ci-dessus !

Compréhension des listes en Python

Avec la récapitulation des listes Python à l'esprit, vous pouvez facilement voir que définir et créer des listes en Python peut être un travail fastidieux : taper toutes les valeurs séparément peut prendre un certain temps et vous pouvez facilement faire des erreurs.

Les compréhensions de listes en Python sont construites comme suit :

list_variable = [x for x in iterable]

Mais comment accéder à cette façon de construire et d'utiliser ces constructions en Python ? Creusons un peu plus loin.

Compréhension de listes en Python : Les mathématiques

Heureusement, Python a la solution pour vous : il vous propose d'implémenter une notation mathématique pour ce faire : la compréhension de liste.

Rappelez-vous qu' en mathématiques, les façons courantes de décrire les listes (ou les ensembles, ou les tuples, ou les vecteurs) sont les suivantes :

S = {x² : x in {0 ... 9}}
V = (1, 2, 4, 8, ..., 2¹²)
M = {x | x in S and x even}

En d'autres termes, vous constaterez que les définitions ci-dessus vous indiquent en fait ce qui suit :

• La séquence S est en fait une séquence qui contient des valeurs comprises entre 0 et 9 incluses qui sont élevées à la puissance deux.
• La séquence V, quant à elle, contient la valeur 2 élevée à une certaine puissance. Pour le premier élément de la séquence, c'est 0, pour le deuxième, c'est 1, et ainsi de suite, jusqu'à ce que vous atteigniez 12.
• Enfin, la séquence M contient des éléments de la séquence S, mais seulement les éléments pairs.

Si les définitions ci-dessus vous donnent mal à la tête, jetez un coup d'œil aux listes réelles que ces définitions produiraient :

S = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
V = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096}
M = {0, 4, 16, 36, 64}

Vous voyez clairement le résultat de chaque liste et les opérations qui y sont décrites !

Maintenant que vous avez compris quelques notions mathématiques sur les listes, vous pouvez traduire ou mettre en œuvre la notation mathématique de la construction des listes en Python en utilisant les compréhensions de listes ! Examinez les lignes de code suivantes :

Tout cela ressemble beaucoup aux définitions mathématiques que vous venez de voir, n'est-ce pas ?

Ne vous inquiétez pas si vous êtes un peu perdu à ce stade ; même si vous n'êtes pas un génie des mathématiques, ces compréhensions de listes sont assez faciles si vous prenez le temps de les étudier. Examinez de plus près le code Python que vous voyez dans le morceau de code ci-dessus.

Vous verrez que le code vous l'indique :

• La liste S est construite avec les crochets que vous avez lus ci-dessus dans la première section. Dans ces parenthèses, vous voyez qu'il y a un élément x, qui est élevé à la puissance 10. Il ne vous reste plus qu'à savoir pour combien de valeurs (et lesquelles !) vous devez élever à la puissance 2. Elle est déterminée à l'adresse range(10). Compte tenu de tous ces éléments, vous pouvez en déduire que vous élèverez tous les nombres, de 0 à 9, à la puissance 2.
• La liste V contient la valeur de base 2, qui est élevée à une certaine puissance. Tout comme précédemment, vous devez maintenant savoir quelle puissance ou i sera utilisée à cette fin. Vous voyez que, dans ce cas, i fait partie de range(13), ce qui signifie que vous partez de 0 et allez jusqu'à 12. Tout cela signifie que votre liste aura 13 valeurs - ces valeurs seront 2 élevées à la puissance 0, 1, 2, ... jusqu'à 12.
• Enfin, la liste M contient des éléments qui font partie de S si - et seulement si - ils peuvent être divisés par 2 sans qu'il en reste. Le modulo doit être égal à 0. En d'autres termes, la liste M est constituée des valeurs égales qui sont stockées dans la liste S.

Maintenant que vous voyez tout cela écrit, c'est beaucoup plus logique, n'est-ce pas ?

Récapitulation et pratique

En bref, vous constatez qu'il y a quelques éléments qui reviennent dans toutes ces lignes de code :

• Les crochets, qui sont une signature des listes de Python ;
• Le mot-clé for, suivi d'une variable symbolisant un élément de liste ; et
• Le mot-clé in, suivi d'une séquence (qui peut être une liste !).

Il en résulte le morceau de code que vous avez vu au début de cette section :

list_variable = [x for x in iterable]

À vous maintenant de vous lancer dans les compréhensions de listes en Python ! Restons proches des listes mathématiques que vous avez déjà vues :

La compréhension des listes comme alternative à...

La compréhension de liste est un substitut complet aux boucles for, à la fonction lambda ainsi qu'aux fonctions map(), filter() et reduce(). De plus, pour certaines personnes, la compréhension des listes peut même être plus facile à comprendre et à utiliser dans la pratique ! Vous en saurez plus à ce sujet dans la section suivante !

Toutefois, si vous souhaitez en savoir plus sur les fonctions et les fonctions lambda en Python, consultez notre tutoriel sur les fonctions en Python.

Boucles de forçage

Comme vous le savez peut-être déjà, les boucles "for" permettent de répéter un bloc de code un nombre fixe de fois. Les compréhensions de listes sont en fait de bonnes alternatives aux boucles for, car elles sont plus compactes. Considérons l'exemple suivant, qui commence par la variable numbers, définie comme un intervalle allant de 0 à 10 (non compris).

N'oubliez pas que le nombre que vous transmettez à la fonction range() est en fait le nombre d'entiers que vous souhaitez générer, en partant de zéro, bien entendu. Cela signifie que range(10) renverra [0,1,2,3,4,5,6,7,8,9].

# Initialize `numbers`
numbers = range(10)

Si vous souhaitez maintenant effectuer une opération sur chaque élément de numbers, vous pouvez le faire à l'aide d'une boucle for, comme celle-ci :

# Initialize `new_list`
new_list = []

# Add values to `new_list`
for n in numbers:
    if n%2==0:
        new_list.append(n**2)

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Tout cela est bien beau, mais considérez maintenant l'exemple suivant de compréhension de liste, où vous faites essentiellement la même chose avec une notation plus compacte :

# Create `new_list` 
new_list = [n**2 for n in numbers if n%2==0]

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Étudions la différence de performance entre la compréhension de liste et la boucle for avec un petit test : vous pouvez mettre cela en place très rapidement avec la bibliothèque timeit, que vous pouvez utiliser pour chronométrer de petits bouts de code Python de manière simple. Dans ce cas, les petits morceaux de code que vous testerez sont la boucle for, que vous placerez dans une fonction appelée power_two() pour plus de commodité, et la compréhension exacte de la liste que vous avez formulée ci-dessus.

Notez que vous devez également indiquer le nombre d'exécutions que vous souhaitez prendre en compte. Dans ce cas, la valeur est fixée à 10000 dans l'argument number.

# Import `timeit`
import timeit

# Print the execution time
print(timeit.timeit('[n**2 for n in range(10) if n%2==0]', number=10000))

0.05234622399802902

# Define `power_two()` 
def power_two(numbers):
    for n in numbers:
        if n%2==0:
            new_list.append(n**2)
    return new_list

# Print the execution time 
print(timeit.timeit('power_two(numbers)', globals=globals(), number=10000))

0.07795589299712447

Notez que dans ce dernier morceau de code, vous ajoutez également l'argument globals, qui fera en sorte que le code soit exécuté dans votre espace de noms global actuel. Ceci est très pratique si vous avez une fonction définie par l'utilisateur (UDF) telle que la fonction power_two() dans l'exemple ci-dessus. Vous pouvez également passer un paramètre setup qui contient une instruction d'importation. Pour en savoir plus , cliquez ici.

Conseil: consultez le tutoriel Loops in Python de DataCamp pour plus d'informations sur les boucles en Python.

Fonctions Lambda avec map(), filter() et reduce()

Les fonctions lambda sont également appelées "fonctions anonymes" ou "fonctions sans nom". Cela signifie que vous n'utilisez ce type de fonctions que lorsqu'elles sont créées. Les fonctions lambda empruntent leur nom au mot-clé lambda de Python, qui est utilisé pour déclarer ces fonctions au lieu du mot-clé standard def.

Vous utilisez généralement ces fonctions en même temps que les fonctions map(), filter() et reduce().

Comment remplacer map() en combinaison avec les fonctions Lambda

Vous pouvez réécrire la combinaison map() et une fonction lambda comme dans l'exemple ci-dessous :

# Initialize the `kilometer` list 
kilometer = [39.2, 36.5, 37.3, 37.8]

# Construct `feet` with `map()`
feet = map(lambda x: float(3280.8399)*x, kilometer)

# Print `feet` as a list 
print(list(feet))

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

Maintenant, vous pouvez facilement remplacer cette combinaison de fonctions qui définissent la variable feet par des compréhensions de listes, en tenant compte des composants dont vous avez pris connaissance dans la section précédente :

• Commencez par les crochets.
• Ajoutez ensuite le corps de la fonction lambda entre ces crochets : float(3280.8399)*x.
• Ensuite, ajoutez le mot-clé for et veillez à répéter l'élément de séquence x, que vous avez déjà référencé en ajoutant le corps de la fonction lambda.
• N'oubliez pas de préciser la provenance de x: ajoutez le mot-clé in, suivi de la séquence à partir de laquelle vous obtiendrez x. Dans ce cas, vous transformerez les éléments de la liste kilometer.

Si vous faites tout cela, vous obtiendrez le résultat suivant :

# Convert `kilometer` to `feet` 
feet = [float(3280.8399)*x for x in kilometer]

# Print `feet`
print(feet)

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

filter() et les fonctions Lambda pour les compréhensions de listes

Maintenant que vous avez vu avec quelle facilité vous pouvez convertir la fonction map() en combinaison avec une fonction lambda, vous pouvez également vous attaquer au code qui contient la fonction Python filter() avec des fonctions lambda et le réécrire.

Prenons l'exemple suivant :

# Map the values of `feet` to integers 
feet = list(map(int, feet))

# Filter `feet` to only include uneven distances 
uneven = filter(lambda x: x%2, feet)

# Check the type of `uneven`
type(uneven)

# Print `uneven` as a list
print(list(uneven))

[122375, 124015]

Pour réécrire les lignes de code de l'exemple ci-dessus, vous pouvez en fait utiliser deux listes de compréhension, stockées dans les variables feet et uneven.

Tout d'abord, vous réécrivez la fonction map(), que vous utilisez pour convertir les éléments de la liste feet en nombres entiers. Ensuite, vous vous attaquez à la fonction filter(): vous prenez le corps de la fonction lambda, vous utilisez les mots-clés for et in pour relier logiquement x et feet:

# Constructing `feet` 
feet = [int(x) for x in feet]

# Print `feet`
print(feet)

# Get all uneven distances
uneven = [x%2 for x in feet]

# Print `uneven`
print(uneven)

[128608, 119750, 122375, 124015]
[0, 0, 1, 1]

Réduire reduce() et les fonctions Lambda en Python

Enfin, vous pouvez également réécrire les fonctions lambda utilisées avec la fonction reduce() en lignes de code plus compactes. Regardez l'exemple suivant :

# Import `reduce` from `functools` 
from functools import reduce

# Reduce `feet` to `reduced_feet`
reduced_feet = reduce(lambda x,y: x+y, feet)

# Print `reduced_feet`
print(reduced_feet)

[128608, 119750, 122375, 124015]
494748

Notez que dans Python 3, la fonction reduce() a été déplacée dans le paquetage functools. Vous devrez donc importer le module pour l'utiliser, comme dans l'exemple de code ci-dessus.

Le morceau de code ci-dessus est assez long, n'est-ce pas ?

Réécrivons ce morceau de code !

Attention ! Vous devez tenir compte du fait que vous ne pouvez pas utiliser y. Les compréhensions de liste ne fonctionnent qu'avec un seul élément, tel que le x que vous avez vu dans les nombreux exemples de ce tutoriel.

Comment allez-vous résoudre ce problème ?

Dans de tels cas, des fonctions d'agrégation telles que sum() peuvent s'avérer utiles :

# Construct `reduced_feet`
reduced_feet = sum([x for x in feet])

# Print `reduced_feet`
print(reduced_feet)

494748

Notez que lorsque vous y réfléchissez, l'utilisation de fonctions d'agrégation lors de la réécriture de la fonction reduce() en combinaison avec une fonction lambda est logique : c'est très similaire à ce que vous faites en SQL lorsque vous utilisez des fonctions d'agrégation pour limiter le nombre d'enregistrements que vous obtenez après l'exécution de votre requête. Dans ce cas, vous utilisez la fonction sum() pour agréger les éléments de feet afin de ne récupérer qu'une seule valeur définitive !

Notez que même si cette approche n'est pas aussi performante en SQL, c'est définitivement la voie à suivre lorsque vous travaillez en Python !

Compréhension de listes avec conditionnels

Maintenant que vous avez compris les bases des compréhensions de listes en Python, il est temps d'ajuster le flux de contrôle de vos compréhensions à l'aide de conditionnelles.

# Define `uneven`
uneven = [x/2 for x in feet if x%2==0]

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Notez que vous pouvez facilement réécrire le morceau de code ci-dessus avec une boucle for de Python !

# Initialize and empty list `uneven` 
uneven = []

# Add values to `uneven` 
for x in feet:
    if x % 2 == 0:
        x = x / 2
        uneven.append(x)

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Conditions multiples de type "si" (If)

Maintenant que vous avez compris comment ajouter des conditions, il est temps de convertir la boucle for suivante en une compréhension de liste avec des conditionnelles.

divided = []

for x in range(100):
    if x%2 == 0 :
        if x%6 == 0:
            divided.append(x)

Attention, vous voyez que la boucle for suivante contient deux conditions ! Réfléchissez bien à la manière dont vous allez résoudre ce problème.

divided = [x for x in range(100) if x % 2 == 0 if x % 6 == 0]

print(divided)

[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]

Conditions If-Else

Bien entendu, il est beaucoup plus courant de travailler avec des conditionnels qui impliquent plus d'une condition. En effet, vous verrez plus souvent if en combinaison avec elif et else. Comment gérer cela si vous prévoyez de réécrire votre code ?

Examinez l'exemple suivant d'une condition plus complexe dans une boucle for :

[x+1 if x >= 120000 else x+5 for x in feet]

[128609, 119755, 122376, 124016]

Regardez maintenant le morceau de code suivant, qui est une réécriture du morceau de code ci-dessus :

for x in feet:  
    if x >= 120000:
        x + 1
    else: 
        x+5

Vous voyez qu'il s'agit essentiellement du même code, mais restructuré : le dernier for x in feet initialise maintenant la boucle for. Ensuite, vous ajoutez la condition if x >= 120000 et la ligne de code que vous voulez exécuter si cette condition est True: x + 1. Si la condition est plutôt False, le dernier morceau de code de votre liste de compréhension est exécuté : x+5.

Compréhensions de listes imbriquées

Outre les conditionnelles, vous pouvez également adapter vos listes de compréhension en les imbriquant dans d'autres listes de compréhension. C'est pratique lorsque vous souhaitez travailler avec des listes de listes : générer des listes de listes, transposer des listes de listes ou aplatir des listes de listes en listes normales, par exemple, devient extrêmement facile avec les compréhensions de listes imbriquées.

Regardez l'exemple suivant :

list_of_list = [[1,2,3],[4,5,6],[7,8]]

# Flatten `list_of_list`
[y for x in list_of_list for y in x]

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

Vous assignez une liste assez simple de listes à une variable list_of_list. À la ligne suivante, vous exécutez une compréhension de liste qui renvoie une liste normale. En réalité, vous prenez les éléments de liste ( y ) des listes imbriquées ( x ) dans list_of_list et vous renvoyez une liste des éléments de liste y qui sont compris dans x.

Vous constatez que la plupart des mots-clés et des éléments utilisés dans l'exemple de compréhension de liste imbriquée sont similaires à ceux que vous avez utilisés dans les exemples de compréhension de liste simple :

• Crochets
• Deux mots-clés for, suivis d'une variable qui symbolise un élément de la liste des listes (x) et un élément d'une liste imbriquée (y) ; et
• Deux mots-clés in, suivis d'une liste de listes (list_of_list) et d'un élément de liste (x).

La plupart des composants sont simplement utilisés deux fois et vous passez à un niveau supérieur (ou plus profond, cela dépend de la façon dont vous voyez les choses !)

Il faut un peu de temps pour s'y habituer, mais c'est assez simple, non ?

Considérons maintenant un autre exemple, dans lequel vous verrez que vous pouvez également utiliser deux paires de crochets pour modifier la logique de la compréhension de votre liste imbriquée :

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

[[row[i] for row in matrix] for i in range(3)]

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

Entraînez-vous maintenant : réécrivez le morceau de code ci-dessus sous la forme d'une boucle for imbriquée. Si vous avez besoin de conseils sur la manière d'aborder cet exercice, consultez l'une des sections précédentes de ce tutoriel.

transposed = []

for i in range(3):
     transposed_row = []
     for row in matrix:
            transposed_row.append(row[i])
     transposed.append(transposed_row)

Vous pouvez également utiliser les compréhensions de listes imbriquées lorsque vous devez créer une liste de listes qui est en fait une matrice. Regardez l'exemple suivant :

matrix = [[0 for col in range(4)] for row in range(3)]

matrix

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Conseil: exercez vos compétences en matière de boucles en Python et réécrivez le morceau de code ci-dessus sous la forme d'une boucle for imbriquée !

Vous trouverez la solution ci-dessous.

for x in range(3):
    nested = []
    matrix.append(nested)
    for row in range(4):
        nested.append(0)

Si vous voulez faire un peu plus de travail, traduisez cette boucle for en une boucle while. Vous trouverez la solution ci-dessous :

x = 0
matrix =[]

while x < 3:
    nested = []
    y = 0
    matrix.append(nested)
    x = x+1
    while y < 4:
        nested.append(0)
        y= y+1

Enfin, il est bon de savoir que vous pouvez également utiliser des fonctions telles que int() pour convertir les entrées de votre liste feet en nombres entiers. En encapsulant [int(x) for x in feet] dans une autre compréhension de liste, vous construisez une matrice ou des listes de votre liste assez facilement :

[[int(x) for x in feet] for x in feet]

[[128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015]]

Maîtriser Python pour la science des données

Félicitations ! Vous êtes arrivé au bout de ce tutoriel, dans lequel vous avez abordé les compréhensions de listes, un mécanisme fréquemment utilisé en Python pour la science des données. Maintenant que vous comprenez le fonctionnement de ce mécanisme, vous êtes prêt à vous attaquer également aux compréhensions de dictionnaires, d'ensembles, ... !

N'oubliez pas que vous pouvez mettre en pratique vos compétences en Python au quotidien grâce au mode d'entraînement journalier de DataCamp ! Vous pouvez le trouver directement sur votre tableau de bord. Si vous ne connaissez pas encore le mode d'entraînement quotidien, lisez ici! Et explorez le catalogue complet des cours Python de DataCamp ici.

Bien que les compréhensions de listes puissent rendre notre code plus succinct, il est important de veiller à ce que notre code final soit aussi lisible que possible, et il convient donc d'éviter les lignes de code très longues pour garantir la convivialité de notre code.