En Python-listeforståelse består af parenteser, der indeholder udtrykket, som udføres for hvert element sammen med for-løkken for at iterere over hvert element i Python-listen.
Eksempel:
Python
numbers>=> [>12>,>13>,>14>,]> doubled>=> [x>*>2> for> x>in> numbers]> print>(doubled)> |
>
>
Produktion
[24, 26, 28]>
Syntaks for forståelse af Python-liste
Syntaks: ny liste = [ udtryk(element) til element i gammel liste hvis tilstand ]
Parameter:
udtryk : Repræsenterer den handling, du vil udføre på hvert element i den iterable. element : Udtrykket variabel refererer til hver værdi taget fra den iterable. iterable : angiv rækkefølgen af elementer, du vil iterere igennem. (f.eks. en liste, tuple eller streng). betingelse : (Valgfrit) Et filter hjælper med at bestemme, om et element skal tilføjes til den nye liste.
Vend tilbage: Returværdien af en listeforståelse er en ny liste, der indeholder de ændrede elementer, der opfylder de givne kriterier.
Python List-forståelse giver en meget mere kort syntaks til at oprette en ny liste baseret på værdierne af en eksisterende liste.
Eksempel på listeforståelse i Python
Her er et eksempel på brug af listeforståelse til at finde kvadratet af tallet i Python.
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>]> squared>=> [x>*>*> 2> for> x>in> numbers]> print>(squared)> |
>
>
Produktion
[1, 4, 9, 16, 25]>
Iteration med Listeforståelse
I dette eksempel tildeler vi 1, 2 og 3 til listen, og vi udskriver listen ved hjælp af Listeforståelse.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> [>1>,>2>,>3>]]> > # Displaying list> print>(>List>)> |
>
>
Produktion
[1, 2, 3]>
Selv liste ved hjælp af listeforståelse
I dette eksempel udskriver vi de lige tal fra 0 til 10 ved hjælp af Listeforståelse.
Python
list> => [i>for> i>in> range>(>11>)>if> i>%> 2> =>=> 0>]> print>(>list>)> |
>
>
Produktion
[0, 2, 4, 6, 8, 10]>
Matrix ved hjælp af listeforståelse
I dette eksempel tildeler vi heltal 0 til 2 til 3 rækker af matrixen og udskriver den ved hjælp af Listeforståelse.
Python
matrix>=> [[j>for> j>in> range>(>3>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Produktion
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Liste forståelser vs for loop
Der er forskellige måder at gentage en liste på. Den mest almindelige tilgang er dog at bruge til sløjfe . Lad os se på nedenstående eksempel:
Python
# Empty list> List> => []> > # Traditional approach of iterating> for> character>in> 'Geeks 4 Geeks!'>:> >List>.append(character)> > # Display list> print>(>List>)> |
>
>
Produktion
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Ovenfor er implementeringen af den traditionelle tilgang til at iterere gennem en liste, streng, tupel osv. Nu udfører listeforståelse i Python den samme opgave og gør også programmet mere enkelt.
Listeforståelser oversætter den traditionelle iterationstilgang vha for sløjfe til en simpel formel, hvilket gør dem nemme at bruge. Nedenfor er fremgangsmåden til at iterere gennem en liste, streng, tuple osv. ved hjælp af listeforståelse i Python.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> 'Geeks 4 Geeks!'>]> > # Displaying list> print>(>List>)> |
>
>
Produktion
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Tidsanalyse i listeforståelser og loop
Listeforståelserne i Python er mere effektive både beregningsmæssigt og med hensyn til kodning af rum og tid end en for en loop. Typisk er de skrevet i en enkelt kodelinje. Nedenstående program viser forskellen mellem loops og listeforståelse baseret på ydeevne.
Python
java tilføje til et array
# 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>))> |
>
>
Produktion
Time taken for_loop: 0.39 Time taken for list_comprehension: 0.35>
Fra ovenstående program kan vi se listeforståelser er ret hurtigere end for loop.
Indlejrede listeforståelser
Indlejrede listeforståelser er intet andet end en listeforståelse inden for en anden listeforståelse, som er ret lig indlejret for loops. Nedenfor er programmet, der implementerer indlejret loop:
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)> |
>
>
Produktion
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Nu ved at bruge indlejrede listeforståelser, kan det samme output genereres i færre linjer kode.
java streng cmp
Python
# Nested list comprehension> matrix>=> [[j>for> j>in> range>(>5>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Produktion
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Listeforståelser og Lambda
Lambda udtryk er intet andet end stenografiske repræsentationer af Python-funktioner. Brug af listeforståelser med lambda skaber en effektiv kombination. Lad os se på nedenstående eksempler:
I dette eksempel indsætter vi tal fra 10 til 50 i listen og udskriver den.
Python
# using lambda to print table of 10> numbers>=> []> > for> i>in> range>(>1>,>6>):> >numbers.append(i>*>10>)> > print>(numbers)> |
>
>
Produktion
[10, 20, 30, 40, 50]>
Her har vi brugt for loop til at udskrive en tabel med 10.
Python
numbers>=> [i>*>10> for> i>in> range>(>1>,>6>)]> > print>(numbers)> |
>
>
Produktion
[10, 20, 30, 40, 50]>
Nu her har vi kun brugt listeforståelse til at vise en tabel med 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)> |
>
>
Produktion
[10, 20, 30, 40, 50]>
Endelig bruger vi lambda + listeforståelse til at vise tabellen med 10. Denne kombination er meget nyttig til at få effektive løsninger på færre linjer kode til komplekse problemer.
Betingelser i Listeforståelse
Vi kan også tilføje betingede udsagn til listeforståelsen. Vi kan lave en liste vha rækkevidde(), operatører , etc. og cal anvender også nogle betingelser på listen ved hjælp af hvis erklæring .
Centrale punkter
- Forståelse af listen er et effektivt middel til at beskrive og konstruere lister baseret på aktuelle lister.
- Generelt er listeforståelse let og enklere end standardlistedannelsesfunktioner og loops.
- Vi bør ikke skrive lange koder til listeforståelse for at sikre brugervenlig kode.
- Enhver forståelse af listen kan omskrives i for loop, men i forbindelse med listefortolkning kan hver for loop ikke omskrives.
Nedenfor er nogle eksempler, der skildrer brugen af listeforståelser snarere end den traditionelle tilgang til iteration gennem iterable:
Python Listeforståelse ved hjælp af If-else.
I eksemplet tjekker vi, at fra 0 til 7, hvis tallet er lige, så indsæt Lige tal til listen ellers indsæt Ulige tal til listen.
Python
lis>=> [>'Even number'> if> i>%> 2> =>=> 0> >else> 'Odd number'> for> i>in> range>(>8>)]> print>(lis)> |
>
>
Produktion
['Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number']>
Indlejret IF med listeforståelse
I dette eksempel indsætter vi tal i listen, som er et multiplum af 10 til 100, og udskriver den.
Python
lis>=> [num>for> num>in> range>(>100>)> >if> num>%> 5> =>=> 0> if> num>%> 10> =>=> 0>]> print>(lis)> |
>
>
Produktion
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]>
Vis et kvadrat med tal fra 1 til 10
I dette eksempel indsætter vi en firkant fra 1 til 10 til listen og udskriver listen.
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)> |
>
>
Produktion
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>
Vis Transponering af 2D-matrix
I dette eksempel laver vi en transponering af matricen ved hjælp af listeforståelse.
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)> |
>
>
Produktion
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]>
Skift mellem store og små bogstaver for hvert tegn i en streng
I dette eksempel skifter vi mellem store og små bogstaver for hvert tegn i en given streng ved hjælp af XOR-operatoren med 32 og gemmer resultatet i en 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>)> |
>
c++ prototype funktion
>
Produktion
['g', 'E', 'E', 'K', 'S', 'x14', 'g', 'E', 'E', 'K', 'S']>
Vend hver streng i en Tuple
I dette eksempel vender vi strenge ind for loop og indsætter dem i listen og udskriver listen.
Python
# Reverse each string in tuple> List> => [string[::>->1>]>for> string>in> (>'Geeks'>,>'for'>,>'Geeks'>)]> > # Display list> print>(>List>)> |
>
>
Produktion
['skeeG', 'rof', 'skeeG']>
Oprettelse af en liste over Tuples fra to separate lister
I dette eksempel har vi lavet to lister over navne og aldre. Vi bruger zip() i listeforståelse, og vi indsætter navn og alder som en tuple til listen. Til sidst udskriver vi listen over tupler.
Python
names>=> [>'G'>,>'G'>,>'g'>]> ages>=> [>25>,>30>,>35>]> person_tuples>=> [(name, age)>for> name, age>in> zip>(names, ages)]> print>(person_tuples)> |
>
>
Produktion:
[('G', 25), ('G', 30), ('g', 35)]> Vis summen af cifre for alle de ulige elementer på en liste.
I dette eksempel har vi lavet en liste, og vi finder ciffersummen af hvert ulige element på listen.
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)> |
>
>
Produktion
[16, 3, 18, 18]>
Fordele ved listeforståelse
- Mere tids- og pladsbesparende end loops.
- Kræv færre linjer kode.
- Transformerer iterativt udsagn til en formel.
Python List forståelsesøvelsesspørgsmål
Nedenfor er to øvelsesspørgsmål om Python-listeforståelse. Vi har dækket grundlæggende listeforståelseskode for at finde terningen af tal og kode for at finde længden af et ord ved hjælp af listeforståelse og len()-funktionen.
Q1. Cube of numbers øvelsesspørgsmål ved hjælp af listeforståelse
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>,>6>,>7>,>8>,>9>,>10>]> cube>=> [number>*>*>3> for> number>in> numbers]> print>(cube)> |
>
>
Produktion
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]>
Q2. Find ordlængde øvelsesspørgsmål ved hjælp af listeforståelse
Python
words>=> [>'apple'>,>'banana'>,>'cherry'>,>'orange'>]> word_lengths>=> [>len>(word)>for> word>in> words]> print>(word_lengths)> |
>
>
Produktion
[5, 6, 6, 6]>