En Python-listförståelse består av parenteser som innehåller uttrycket, som exekveras för varje element tillsammans med for-loopen för att iterera över varje element i Python-listan.
Exempel:
Pytonorm
numbers>=> [>12>,>13>,>14>,]> doubled>=> [x>*>2> for> x>in> numbers]> print>(doubled)> |
>
>
Produktion
[24, 26, 28]>
Syntax för förståelse av Python-listan
Syntax: ny lista = [ expression(element) för element i gammal lista om skick ]
Parameter:
expression : Representerar operationen du vill utföra på varje objekt inom iterabeln. element : Termen variabel hänvisar till varje värde hämtat från iterabeln. iterable : ange sekvensen av element som du vill iterera igenom. (t.ex. en lista, tuppel eller sträng). condition : (Valfritt) Ett filter hjälper till att avgöra om ett element ska läggas till i den nya listan eller inte.
Lämna tillbaka: Returvärdet för en listförståelse är en ny lista som innehåller de modifierade elementen som uppfyller de givna kriterierna.
Python List-förståelse ger en mycket kortare syntax för att skapa en ny lista baserad på värdena i en befintlig lista.
Listförståelse i Python-exempel
Här är ett exempel på hur man använder listförståelse för att hitta kvadraten på talet i Python.
Pytonorm
numbers>=> [>1>,>2>,>3>,>4>,>5>]> squared>=> [x>*>*> 2> for> x>in> numbers]> print>(squared)> |
>
>
Produktion
[1, 4, 9, 16, 25]>
Iteration med listförståelse
I det här exemplet tilldelar vi listan 1, 2 och 3 och vi skriver ut listan med Listförståelse.
Pytonorm
# Using list comprehension to iterate through loop> List> => [character>for> character>in> [>1>,>2>,>3>]]> > # Displaying list> print>(>List>)> |
>
>
Produktion
[1, 2, 3]>
Jämn lista med listförståelse
I det här exemplet skriver vi ut de jämna talen från 0 till 10 med hjälp av listförståelse.
Pytonorm
list> => [i>for> i>in> range>(>11>)>if> i>%> 2> =>=> 0>]> print>(>list>)> |
>
>
Produktion
[0, 2, 4, 6, 8, 10]>
Matris med hjälp av listförståelse
I det här exemplet tilldelar vi heltal 0 till 2 till 3 rader i matrisen och skriver ut den med hjälp av listförståelse.
Pytonorm
matrix>=> [[j>for> j>in> range>(>3>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Produktion
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Lista förståelser vs för loop
Det finns olika sätt att iterera genom en lista. Det vanligaste tillvägagångssättet är dock att använda för slinga . Låt oss titta på exemplet nedan:
Pytonorm
# 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', '!']>
Ovan är implementeringen av den traditionella metoden att iterera genom en lista, sträng, tupel, etc. Nu gör listförståelse i Python samma uppgift och gör också programmet enklare.
Listförståelser översätter den traditionella iterationsmetoden med hjälp av för slinga till en enkel formel vilket gör dem lätta att använda. Nedan är tillvägagångssättet för att iterera genom en lista, sträng, tuppel, etc. med hjälp av listförståelse i Python.
Pytonorm
# 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', '!']>
Tidsanalys i listförståelser och loop
Listförståelserna i Python är mer effektiva både beräkningsmässigt och när det gäller kodningsutrymme och tid än en för en loop. Vanligtvis skrivs de i en enda kodrad. Nedanstående program visar skillnaden mellan loopar och listförståelse baserat på prestanda.
Pytonorm
c# innehåller sträng
# 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>
Från programmet ovan kan vi se att listförståelser är ganska snabbare än för loop.
Kapslade listförståelser
Kapslade listförståelser är inget annat än en listförståelse inom en annan listförståelse som är ganska lik kapslad för loopar. Nedan är programmet som implementerar kapslad loop:
Pytonorm
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]]>
Genom att använda kapslade listförståelser kan samma utdata genereras i färre rader kod.
Pytonorm
# 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]]>
Listförståelser och Lambda
Lambda uttryck är inget annat än stenografirepresentationer av Python-funktioner. Att använda listförståelser med lambda skapar en effektiv kombination. Låt oss titta på nedanstående exempel:
I det här exemplet infogar vi siffror från 10 till 50 i listan och skriver ut den.
Pytonorm
# 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]>
Här har vi använt för loop för att skriva ut en tabell med 10.
Pytonorm
numbers>=> [i>*>10> for> i>in> range>(>1>,>6>)]> > print>(numbers)> |
>
>
Produktion
dijkstra
[10, 20, 30, 40, 50]>
Nu här har vi bara använt listförståelse för att visa en tabell med 10.
Pytonorm
# 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]>
Slutligen använder vi lambda + listförståelse för att visa tabellen med 10. Denna kombination är mycket användbar för att få effektiva lösningar på färre rader kod för komplexa problem.
Villkor i listförståelse
Vi kan också lägga till villkorliga uttalanden till listförståelsen. Vi kan skapa en lista med hjälp av räckvidd(), operatörer , etc. och cal tillämpar också vissa villkor på listan med hjälp av om uttalande .
Nyckelord
- Förståelse av listan är ett effektivt sätt att beskriva och konstruera listor baserade på aktuella listor.
- I allmänhet är listförståelse lätt och enklare än vanliga listbildningsfunktioner och loopar.
- Vi bör inte skriva långa koder för listförståelse för att säkerställa användarvänlig kod.
- Varje förståelse av listan kan skrivas om i for loop, men i samband med listtolkning kan varje for loop inte skrivas om.
Nedan följer några exempel som skildrar användningen av listförståelse snarare än den traditionella metoden att iterera genom iterabel:
Python Listförståelse med If-else.
I exemplet kontrollerar vi att från 0 till 7 om talet är jämnt, infoga sedan Jämnt nummer till listan annars infogas Udda nummer till listan.
Pytonorm
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']>
Kapslad IF med listförståelse
I det här exemplet infogar vi siffror i listan som är en multipel av 10 till 100 och skriver ut den.
Pytonorm
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]>
Visa en kvadrat med tal från 1 till 10
I det här exemplet infogar vi en kvadrat från 1 till 10 i listan och skriver ut listan.
Pytonorm
# 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]>
Display Transponering av 2D-matris
I det här exemplet gör vi en transponering av matrisen med hjälp av listförståelse.
Pytonorm
# 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]]>
Växla skiftläge för varje tecken i en sträng
I det här exemplet växlar vi skiftläge för varje tecken i en given sträng med XOR-operatorn med 32 och lagrar resultatet i en lista.
Pytonorm
# Initializing string> string>=> 'Geeks4Geeks'> > # Toggle case of each character> List> => list>(>map>(>lambda> i:>chr>(>ord>(i) ^>32>), string))> > # Display list> print>(>List>)> |
>
>
Produktion
['g', 'E', 'E', 'K', 'S', 'x14', 'g', 'E', 'E', 'K', 'S']>
Vänd varje sträng i en Tuple
I det här exemplet vänder vi om strängar för loop och infogar dem i listan och skriver ut listan.
Pytonorm
# Reverse each string in tuple> List> => [string[::>->1>]>for> string>in> (>'Geeks'>,>'for'>,>'Geeks'>)]> > # Display list> print>(>List>)> |
>
>
Produktion
['skeeG', 'rof', 'skeeG']>
Skapa en lista över Tuples från två separata listor
I det här exemplet har vi skapat två listor med namn och åldrar. Vi använder blixtlås() i listförståelse och vi lägger in namn och ålder som en tupel till lista. Äntligen skriver vi ut listan över tupler.
Pytonorm
names>=> [>'G'>,>'G'>,>'g'>]> ages>=> [>25>,>30>,>35>]> person_tuples>=> [(name, age)>for> name, age>in> zip>(names, ages)]> print>(person_tuples)> |
>
sql-satser
>
Produktion:
[('G', 25), ('G', 30), ('g', 35)]> Visa summan av siffror för alla udda element i en lista.
I det här exemplet har vi skapat en lista och vi hittar siffersumman för varje udda element i listan.
Pytonorm
# 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]>
Fördelar med listförståelse
- Mer tidseffektivt och utrymmeseffektivt än loopar.
- Kräv färre rader kod.
- Omvandlar iterativt påstående till en formel.
Python Lista Förståelse Övningsfrågor
Nedan finns två övningsfrågor om Python-listförståelse. Vi har täckt grundläggande listförståelsekod för att hitta kuben av siffror och kod för att hitta längden på ett ord med hjälp av listförståelse och len()-funktionen.
Q1. Träningsfråga med siffror med hjälp av listförståelse
Pytonorm
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. Att hitta ordlängdsövningsfråga med hjälp av listförståelse
Pytonorm
words>=> [>'apple'>,>'banana'>,>'cherry'>,>'orange'>]> word_lengths>=> [>len>(word)>for> word>in> words]> print>(word_lengths)> |
>
>
Produktion
[5, 6, 6, 6]>