O listă de înțelegere Python constă din paranteze care conțin expresia, care este executată pentru fiecare element împreună cu bucla for pentru a repeta fiecare element din lista Python.
Exemplu:
Piton
numbers>=> [>12>,>13>,>14>,]> doubled>=> [x>*>2> for> x>in> numbers]> print>(doubled)> |
>
>
Ieșire
[24, 26, 28]>
Sintaxa de înțelegere a listei Python
Sintaxă: listă nouă = [ expresie (element) pentru element în lista veche dacă condiție ]
Parametru:
expresie : Reprezintă operația pe care doriți să o executați pentru fiecare element din iterabil. element : Termenul variabilă se referă la fiecare valoare luată din iterabil. iterabil: specificați secvența de elemente prin care doriți să iterați. (de exemplu, o listă, un tuplu sau șir). condiție : (Opțional) Un filtru vă ajută să decideți dacă un element trebuie sau nu adăugat la noua listă.
Întoarcere: Valoarea returnată a unei liste de înțelegere este o listă nouă care conține elementele modificate care îndeplinesc criteriile date.
Înțelegerea listei Python oferă o sintaxă mult mai scurtă pentru crearea unei liste noi bazate pe valorile unei liste existente.
Exemplu de înțelegere a listei în Python
Iată un exemplu de utilizare a înțelegerii listei pentru a găsi pătratul numărului în Python.
Piton
numbers>=> [>1>,>2>,>3>,>4>,>5>]> squared>=> [x>*>*> 2> for> x>in> numbers]> print>(squared)> |
>
>
Ieșire
[1, 4, 9, 16, 25]>
Iterație cu Lista de înțelegere
În acest exemplu, atribuim 1, 2 și 3 listei și tipărim lista utilizând Lista de înțelegere.
Piton
# Using list comprehension to iterate through loop> List> => [character>for> character>in> [>1>,>2>,>3>]]> > # Displaying list> print>(>List>)> |
>
>
Ieșire
[1, 2, 3]>
Lista chiar folosind Lista de înțelegere
În acest exemplu, tipărim numerele pare de la 0 la 10 utilizând Lista de înțelegere.
Piton
list> => [i>for> i>in> range>(>11>)>if> i>%> 2> =>=> 0>]> print>(>list>)> |
>
>
Ieșire
[0, 2, 4, 6, 8, 10]>
Matrice folosind Lista de înțelegere
În acest exemplu, atribuim numere întregi de la 0 la 2 până la 3 rânduri ale matricei și o tipărim utilizând Lista de înțelegere.
Piton
matrix>=> [[j>for> j>in> range>(>3>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Ieșire
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Liste Comprehensions vs For Loop
Există mai multe moduri de a parcurge o listă. Cu toate acestea, cea mai comună abordare este utilizarea pentru buclă . Să ne uităm la exemplul de mai jos:
Piton
# Empty list> List> => []> > # Traditional approach of iterating> for> character>in> 'Geeks 4 Geeks!'>:> >List>.append(character)> > # Display list> print>(>List>)> |
>
>
Ieșire
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Mai sus este implementarea abordării tradiționale de a itera printr-o listă, șir, tuplu etc. Acum, înțelegerea listei în Python face aceeași sarcină și, de asemenea, face programul mai simplu.
List Comprehensions traduce abordarea tradițională de iterație folosind pentru buclă într-o formulă simplă, făcându-le ușor de utilizat. Mai jos este abordarea de a itera printr-o listă, șir, tuplu etc. folosind înțelegerea listei în Python.
Piton
# Using list comprehension to iterate through loop> List> => [character>for> character>in> 'Geeks 4 Geeks!'>]> > # Displaying list> print>(>List>)> |
>
>
Ieșire
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Analiza timpului în liste de înțelegeri și buclă
Listele de înțelegere în Python sunt mai eficiente atât din punct de vedere computațional, cât și din punct de vedere al spațiului și al timpului de codare decât o buclă for. De obicei, acestea sunt scrise într-o singură linie de cod. Programul de mai jos descrie diferența dintre bucle și înțelegerea listei pe baza performanței.
Piton
iterator java pentru hartă
# 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>))> |
>
>
Ieșire
Time taken for_loop: 0.39 Time taken for list_comprehension: 0.35>
Din programul de mai sus, putem vedea că listele de înțelegere sunt destul de mai rapide decât pentru bucla.
Înțelegeri liste imbricate
Înțelegeri liste imbricate nu sunt altceva decât o listă de înțelegere într-o altă listă de înțelegere care este destul de similară cu buclele imbricate pentru. Mai jos este programul care implementează bucla imbricată:
Piton
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)> |
>
>
Ieșire
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Acum, prin utilizarea listelor de înțelegere imbricate, aceeași ieșire poate fi generată în mai puține linii de cod.
Piton
# Nested list comprehension> matrix>=> [[j>for> j>in> range>(>5>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Ieșire
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Lista de înțelegeri și Lambda
Expresii Lambda nu sunt altceva decât reprezentări scurte ale funcțiilor Python. Folosirea listelor de înțelegere cu lambda creează o combinație eficientă. Să ne uităm la exemplele de mai jos:
În acest exemplu, inserăm numere de la 10 la 50 în listă și o tipărim.
Piton
# using lambda to print table of 10> numbers>=> []> > for> i>in> range>(>1>,>6>):> >numbers.append(i>*>10>)> > print>(numbers)> |
>
>
Ieșire
[10, 20, 30, 40, 50]>
Aici, am folosit for loop pentru a tipări un tabel de 10.
Piton
numbers>=> [i>*>10> for> i>in> range>(>1>,>6>)]> > print>(numbers)> |
>
>
Ieșire
[10, 20, 30, 40, 50]>
Acum, aici, am folosit doar înțelegerea listelor pentru a afișa un tabel cu 10.
Piton
# using lambda to print table of 10> numbers>=> list>(>map>(>lambda> i: i>*>10>, [i>for> i>in> range>(>1>,>6>)]))> > print>(numbers)> |
>
>
Ieșire
[10, 20, 30, 40, 50]>
În cele din urmă, folosim lambda + listă de înțelegere pentru a afișa tabelul cu 10. Această combinație este foarte utilă pentru a obține soluții eficiente în mai puține linii de cod pentru probleme complexe.
Condiționale în înțelegerea listelor
Putem adăuga, de asemenea, declarații condiționale la înțelegerea listei. Putem crea o listă folosind gamă(), operatori , etc. și cal aplică, de asemenea, unele condiții listei folosind declarația dacă .
Puncte cheie
ce este un sistem de fișiere linux
- Înțelegerea listei este un mijloc eficient de a descrie și a construi liste pe baza listelor curente.
- În general, înțelegerea listelor este ușoară și mai simplă decât funcțiile și buclele standard de formare a listelor.
- Nu ar trebui să scriem coduri lungi pentru înțelegerea listelor pentru a asigura un cod ușor de utilizat.
- Fiecare înțelegere a listei poate fi rescrisă în bucla for, dar în contextul interpretării listei, fiecare buclă for nu poate fi rescrisă.
Mai jos sunt câteva exemple care descriu utilizarea listelor de înțelegere mai degrabă decât abordarea tradițională de a repeta prin iterabil:
Înțelegerea listei Python folosind If-else.
În exemplu, verificăm că de la 0 la 7 dacă numărul este par, atunci inserăm Număr par la listă altfel inserați Numar impar la listă.
Piton
lis>=> [>'Even number'> if> i>%> 2> =>=> 0> >else> 'Odd number'> for> i>in> range>(>8>)]> print>(lis)> |
>
>
Ieșire
['Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number']>
IF imbricat cu lista de înțelegere
În acest exemplu, inserăm numere în listă care este un multiplu de la 10 la 100 și o tipărim.
Piton
lis>=> [num>for> num>in> range>(>100>)> >if> num>%> 5> =>=> 0> if> num>%> 10> =>=> 0>]> print>(lis)> |
>
>
Ieșire
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]>
Afișați un pătrat de numere de la 1 la 10
În acest exemplu, inserăm un pătrat de la 1 la 10 pentru a lista și tipărim lista.
Piton
# Getting square of number from 1 to 10> squares>=> [n>*>*>2> for> n>in> range>(>1>,>11>)]> > # Display square of even numbers> print>(squares)> |
>
>
Ieșire
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>
Afișează transpunerea matricei 2D
În acest exemplu, facem o transpunere a matricei folosind înțelegerea listei.
Piton
# 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)> |
>
>
Ieșire
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]>
Comutați între majuscule și minuscule ale fiecărui caracter dintr-un șir
În acest exemplu, comutăm între majuscule și minuscule ale fiecărui caracter dintr-un șir dat folosind operatorul XOR cu 32 și stocăm rezultatul într-o listă.
Piton
# Initializing string> string>=> 'Geeks4Geeks'> > # Toggle case of each character> List> => list>(>map>(>lambda> i:>chr>(>ord>(i) ^>32>), string))> > # Display list> print>(>List>)> |
>
>
obj în java
Ieșire
['g', 'E', 'E', 'K', 'S', 'x14', 'g', 'E', 'E', 'K', 'S']>
Inversați fiecare șir într-un tuplu
În acest exemplu, inversăm șirurile în bucla for și le inserăm în listă și tipărim lista.
Piton
# Reverse each string in tuple> List> => [string[::>->1>]>for> string>in> (>'Geeks'>,>'for'>,>'Geeks'>)]> > # Display list> print>(>List>)> |
>
>
Ieșire
['skeeG', 'rof', 'skeeG']>
Crearea unei liste de tupluri din două liste separate
În acest exemplu, am creat două liste de nume și vârste. Noi folosim zip() în înțelegerea listei și inserăm numele și vârsta ca tuplu în listă. În cele din urmă, imprimăm lista de tupluri.
Piton
names>=> [>'G'>,>'G'>,>'g'>]> ages>=> [>25>,>30>,>35>]> person_tuples>=> [(name, age)>for> name, age>in> zip>(names, ages)]> print>(person_tuples)> |
>
>
Ieșire:
[('G', 25), ('G', 30), ('g', 35)]> Afișează suma cifrelor tuturor elementelor impare dintr-o listă.
În acest exemplu, am creat o listă și găsim suma cifrelor fiecărui element impar din listă.
Piton
# 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)> |
>
>
Ieșire
[16, 3, 18, 18]>
Avantajele înțelegerii listelor
- Mai eficient în timp și în spațiu decât buclele.
- Necesită mai puține linii de cod.
- Transformă declarația iterativă într-o formulă.
Întrebări pentru exercițiul de înțelegere a listei Python
Mai jos sunt două întrebări de exercițiu despre înțelegerea listei Python. Am acoperit codul de bază de înțelegere a listei pentru a găsi cubul de numere și codul pentru a găsi lungimea unui cuvânt folosind înțelegerea listei și funcția len().
Î1. Întrebarea exercițiului cub de numere folosind înțelegerea listei
Piton
numbers>=> [>1>,>2>,>3>,>4>,>5>,>6>,>7>,>8>,>9>,>10>]> cube>=> [number>*>*>3> for> number>in> numbers]> print>(cube)> |
>
>
Ieșire
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]>
Q2. Întrebare exercițiu pentru găsirea lungimii cuvintelor folosind înțelegerea listei
Piton
words>=> [>'apple'>,>'banana'>,>'cherry'>,>'orange'>]> word_lengths>=> [>len>(word)>for> word>in> words]> print>(word_lengths)> |
>
>
Ieșire
[5, 6, 6, 6]>