Une compréhension de liste Python se compose de crochets contenant l'expression, qui est exécutée pour chaque élément avec la boucle for pour parcourir chaque élément de la liste Python.
Exemple:
Python
numbers>=> [>12>,>13>,>14>,]> doubled>=> [x>*>2> for> x>in> numbers]> print>(doubled)> |
>
>
Sortir
[24, 26, 28]>
Syntaxe de compréhension de liste Python
Syntaxe: Nouvelle liste = [ expression(élément) pour élément dans ancienneListe si condition ]
Paramètre:
expression : représente l'opération que vous souhaitez exécuter sur chaque élément de l'itérable. element : Le terme variable fait référence à chaque valeur extraite de l'itérable. itérable : spécifiez la séquence d'éléments sur laquelle vous souhaitez parcourir (par exemple, une liste, un tuple ou une chaîne). condition : (Facultatif) Un filtre permet de décider si un élément doit ou non être ajouté à la nouvelle liste.
Retour: La valeur de retour d'une compréhension de liste est une nouvelle liste contenant les éléments modifiés qui satisfont aux critères donnés.
La compréhension de liste Python fournit une syntaxe beaucoup plus courte pour créer une nouvelle liste basée sur les valeurs d'une liste existante.
Compréhension de liste dans un exemple Python
Voici un exemple d'utilisation de la compréhension de liste pour trouver le carré du nombre en Python.
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>]> squared>=> [x>*>*> 2> for> x>in> numbers]> print>(squared)> |
>
>
Sortir
[1, 4, 9, 16, 25]>
Itération avec compréhension de liste
Dans cet exemple, nous attribuons 1, 2 et 3 à la liste et nous imprimons la liste en utilisant la compréhension de liste.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> [>1>,>2>,>3>]]> > # Displaying list> print>(>List>)> |
>
>
Sortir
[1, 2, 3]>
Liste uniforme utilisant la compréhension de liste
Dans cet exemple, nous imprimons les nombres pairs de 0 à 10 en utilisant la compréhension de liste.
Python
list> => [i>for> i>in> range>(>11>)>if> i>%> 2> =>=> 0>]> print>(>list>)> |
>
>
Sortir
[0, 2, 4, 6, 8, 10]>
Matrice utilisant la compréhension de liste
Dans cet exemple, nous attribuons des entiers 0 à 2 à 3 lignes de la matrice et l'imprimons à l'aide de la compréhension de liste.
Python
matrix>=> [[j>for> j>in> range>(>3>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Sortir
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Compréhensions de liste vs boucle For
Il existe différentes manières de parcourir une liste. Cependant, l'approche la plus courante consiste à utiliser le pour boucle . Regardons l'exemple ci-dessous :
Python
# Empty list> List> => []> > # Traditional approach of iterating> for> character>in> 'Geeks 4 Geeks!'>:> >List>.append(character)> > # Display list> print>(>List>)> |
>
>
Sortir
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Ci-dessus se trouve l'implémentation de l'approche traditionnelle pour parcourir une liste, une chaîne, un tuple, etc. Désormais, la compréhension de liste en Python effectue la même tâche et rend également le programme plus simple.
Les compréhensions de listes traduisent l'approche itérative traditionnelle en utilisant pour la boucle dans une formule simple, ce qui les rend faciles à utiliser. Vous trouverez ci-dessous l'approche pour parcourir une liste, une chaîne, un tuple, etc. en utilisant la compréhension de liste en Python.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> 'Geeks 4 Geeks!'>]> > # Displaying list> print>(>List>)> |
>
>
Sortir
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Analyse du temps dans les compréhensions de listes et les boucles
Les compréhensions de listes en Python sont plus efficaces à la fois en termes de calcul et en termes d'espace et de temps de codage qu'une boucle for. Généralement, ils sont écrits sur une seule ligne de code. Le programme ci-dessous décrit la différence entre les boucles et la compréhension de liste en fonction des performances.
Python
jdbc jdbc
# Import required module> import> time> > > # define function to implement for loop> def> for_loop(n):> >result>=> []> >for> i>in> range>(n):> >result.append(i>*>*>2>)> >return> result> > > # define function to implement list comprehension> def> list_comprehension(n):> >return> [i>*>*>2> for> i>in> range>(n)]> > > # Driver Code> > # Calculate time taken by for_loop()> begin>=> time.time()> for_loop(>10>*>*>6>)> end>=> time.time()> > # Display time taken by for_loop()> print>(>'Time taken for_loop:'>,>round>(end>->begin,>2>))> > # Calculate time takens by list_comprehension()> begin>=> time.time()> list_comprehension(>10>*>*>6>)> end>=> time.time()> > # Display time taken by for_loop()> print>(>'Time taken for list_comprehension:'>,>round>(end>->begin,>2>))> |
>
>
Sortir
Time taken for_loop: 0.39 Time taken for list_comprehension: 0.35>
À partir du programme ci-dessus, nous pouvons voir que les compréhensions de listes sont beaucoup plus rapides que celles de la boucle for.
Compréhensions de listes imbriquées
Compréhensions de listes imbriquées ne sont rien d'autre qu'une compréhension de liste au sein d'une autre compréhension de liste qui est assez similaire aux boucles for imbriquées. Ci-dessous le programme qui implémente la boucle imbriquée :
Python
matrix>=> []> > for> i>in> range>(>3>):> > ># Append an empty sublist inside the list> >matrix.append([])> > >for> j>in> range>(>5>):> >matrix[i].append(j)> > print>(matrix)> |
>
>
Sortir
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Désormais, en utilisant des compréhensions de listes imbriquées, le même résultat peut être généré en moins de lignes de code.
Python
# Nested list comprehension> matrix>=> [[j>for> j>in> range>(>5>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Sortir
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Compréhensions de listes et Lambda
Expressions lambda ne sont rien d’autre que des représentations abrégées des fonctions Python. L'utilisation de compréhensions de liste avec lambda crée une combinaison efficace. Regardons les exemples ci-dessous :
Dans cet exemple, nous insérons des nombres de 10 à 50 dans la liste et l'imprimons.
Python
# using lambda to print table of 10> numbers>=> []> > for> i>in> range>(>1>,>6>):> >numbers.append(i>*>10>)> > print>(numbers)> |
>
>
Sortir
Le processus Android Acore continue de s'arrêter
[10, 20, 30, 40, 50]>
Ici, nous avons utilisé la boucle for pour imprimer un tableau de 10.
Python
numbers>=> [i>*>10> for> i>in> range>(>1>,>6>)]> > print>(numbers)> |
>
>
Sortir
[10, 20, 30, 40, 50]>
Maintenant, ici, nous avons utilisé uniquement la compréhension de liste pour afficher un tableau de 10.
Python
# using lambda to print table of 10> numbers>=> list>(>map>(>lambda> i: i>*>10>, [i>for> i>in> range>(>1>,>6>)]))> > print>(numbers)> |
>
>
Sortir
[10, 20, 30, 40, 50]>
Enfin, nous utilisons la compréhension de liste lambda + pour afficher le tableau de 10. Cette combinaison est très utile pour obtenir des solutions efficaces en moins de lignes de code pour des problèmes complexes.
Conditions dans la compréhension de liste
Nous pouvons également ajouter des instructions conditionnelles à la compréhension de la liste. Nous pouvons créer une liste en utilisant gamme(), les opérateurs , etc. et cal applique également certaines conditions à la liste en utilisant le si déclaration .
Points clés
- La compréhension de la liste est un moyen efficace de décrire et de construire des listes basées sur les listes actuelles.
- Généralement, la compréhension de liste est légère et plus simple que les fonctions et boucles standard de formation de liste.
- Nous ne devons pas écrire de codes longs pour la compréhension de listes afin de garantir un code convivial.
- Chaque compréhension de la liste peut être réécrite dans une boucle for, mais dans le contexte de l'interprétation d'une liste, chaque boucle for ne peut pas être réécrite.
Vous trouverez ci-dessous quelques exemples illustrant l'utilisation de compréhensions de listes plutôt que l'approche traditionnelle pour parcourir itérable :
Compréhension de liste Python à l'aide de If-else.
Dans l'exemple, nous vérifions que de 0 à 7 si le nombre est pair alors insérez Nombre pair à la liste sinon insérer Nombre impair à la liste.
Python
lis>=> [>'Even number'> if> i>%> 2> =>=> 0> >else> 'Odd number'> for> i>in> range>(>8>)]> print>(lis)> |
>
>
Sortir
['Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number']>
IF imbriqué avec compréhension de liste
Dans cet exemple, nous insérons des nombres dans la liste qui sont un multiple de 10 à 100 et l'imprimons.
Python
lis>=> [num>for> num>in> range>(>100>)> >if> num>%> 5> =>=> 0> if> num>%> 10> =>=> 0>]> print>(lis)> |
>
>
Sortir
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]>
Afficher un carré de nombres de 1 à 10
Dans cet exemple, nous insérons un carré de 1 à 10 dans la liste et imprimons la liste.
Python
# Getting square of number from 1 to 10> squares>=> [n>*>*>2> for> n>in> range>(>1>,>11>)]> > # Display square of even numbers> print>(squares)> |
>
>
Sortir
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>
Afficher la transposition de la matrice 2D
Dans cet exemple, nous effectuons une transposition de la matrice en utilisant la compréhension de liste.
Python
# Assign matrix> twoDMatrix>=> [[>10>,>20>,>30>],> >[>40>,>50>,>60>],> >[>70>,>80>,>90>]]> > # Generate transpose> trans>=> [[i[j]>for> i>in> twoDMatrix]>for> j>in> range>(>len>(twoDMatrix[>0>]))]> > print>(trans)> |
>
>
Sortir
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]>
Basculer la casse de chaque caractère dans une chaîne
Dans cet exemple, nous changeons la casse de chaque caractère dans une chaîne donnée en utilisant l'opérateur XOR avec 32 et stockons le résultat dans une liste.
Python
# Initializing string> string>=> 'Geeks4Geeks'> > # Toggle case of each character> List> => list>(>map>(>lambda> i:>chr>(>ord>(i) ^>32>), string))> > # Display list> print>(>List>)> |
>
>
Sortir
['g', 'E', 'E', 'K', 'S', 'x14', 'g', 'E', 'E', 'K', 'S']>
Inverser chaque chaîne dans un tuple
Dans cet exemple, nous inversons les chaînes dans la boucle for, les insérons dans la liste et imprimons la liste.
Python
# Reverse each string in tuple> List> => [string[::>->1>]>for> string>in> (>'Geeks'>,>'for'>,>'Geeks'>)]> > # Display list> print>(>List>)> |
>
>
Sortir
['skeeG', 'rof', 'skeeG']>
Création d'une liste de tuples à partir de deux listes distinctes
Dans cet exemple, nous avons créé deux listes de noms et âges. Nous utilisons fermeture éclair() dans la compréhension de la liste et nous insérons le nom et l'âge sous forme de tuple dans la liste. Enfin, nous imprimons la liste des tuples.
méthode java
Python
names>=> [>'G'>,>'G'>,>'g'>]> ages>=> [>25>,>30>,>35>]> person_tuples>=> [(name, age)>for> name, age>in> zip>(names, ages)]> print>(person_tuples)> |
>
>
Sortir:
[('G', 25), ('G', 30), ('g', 35)]> Afficher la somme des chiffres de tous les éléments impairs d'une liste.
Dans cet exemple, nous avons créé une liste et nous trouvons la somme des chiffres de chaque élément impair de la liste.
Python
# Explicit function> def> digitSum(n):> >dsum>=> 0> >for> ele>in> str>(n):> >dsum>+>=> int>(ele)> >return> dsum> > > # Initializing list> List> => [>367>,>111>,>562>,>945>,>6726>,>873>]> > # Using the function on odd elements of the list> newList>=> [digitSum(i)>for> i>in> List> if> i &>1>]> > # Displaying new list> print>(newList)> |
>
>
Sortir
[16, 3, 18, 18]>
Avantages de la compréhension de liste
- Plus efficace en termes de temps et d'espace que les boucles.
- Nécessite moins de lignes de code.
- Transforme l'instruction itérative en formule.
Questions d'exercices de compréhension de liste Python
Vous trouverez ci-dessous deux questions d'exercices sur la compréhension des listes Python. Nous avons couvert le code de base de compréhension de liste pour trouver le cube de nombres et le code pour trouver la longueur d'un mot en utilisant la compréhension de liste et la fonction len().
T1. Question d'exercice sur le cube de nombres utilisant la compréhension de liste
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>,>6>,>7>,>8>,>9>,>10>]> cube>=> [number>*>*>3> for> number>in> numbers]> print>(cube)> |
>
>
Sortir
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]>
Q2. Trouver une question d'exercice sur la longueur des mots en utilisant la compréhension de liste
Python
words>=> [>'apple'>,>'banana'>,>'cherry'>,>'orange'>]> word_lengths>=> [>len>(word)>for> word>in> words]> print>(word_lengths)> |
>
>
Sortir
[5, 6, 6, 6]>