Razumevanje seznama Python je sestavljeno iz oklepajev, ki vsebujejo izraz, ki se izvede za vsak element skupaj z zanko for za ponavljanje vsakega elementa na seznamu Python.
primer:
Python
numbers>=> [>12>,>13>,>14>,]> doubled>=> [x>*>2> for> x>in> numbers]> print>(doubled)> |
>
>
Izhod
[24, 26, 28]>
Sintaksa razumevanja seznama Python
Sintaksa: newList = [ izraz (element) za element v oldList če stanje ]
Parameter:
izraz : Predstavlja operacijo, ki jo želite izvesti na vsakem elementu znotraj ponovljivega. element : Izraz spremenljivka se nanaša na vsako vrednost, vzeto iz iterable. iterable : določite zaporedje elementov, skozi katere želite iterirati. (npr. seznam, tuple ali niz). pogoj : (Izbirno) Filter pomaga pri odločitvi, ali je treba element dodati na nov seznam ali ne.
Vrnitev: Povratna vrednost razumevanja seznama je nov seznam, ki vsebuje spremenjene elemente, ki izpolnjujejo dane kriterije.
Razumevanje seznama v Pythonu ponuja veliko krajšo sintakso za ustvarjanje novega seznama na podlagi vrednosti obstoječega seznama.
Primer razumevanja seznama v Pythonu
Tukaj je primer uporabe seznamskega razumevanja za iskanje kvadrata števila v Pythonu.
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>]> squared>=> [x>*>*> 2> for> x>in> numbers]> print>(squared)> |
>
>
Izhod
[1, 4, 9, 16, 25]>
Ponavljanje z razumevanjem seznama
V tem primeru seznamu dodeljujemo 1, 2 in 3 in seznam natisnemo z razumevanjem seznama.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> [>1>,>2>,>3>]]> > # Displaying list> print>(>List>)> |
>
>
Izhod
[1, 2, 3]>
Enakomerni seznam z uporabo funkcije List Comprehension
V tem primeru tiskamo soda števila od 0 do 10 z uporabo seznamskega razumevanja.
Python
list> => [i>for> i>in> range>(>11>)>if> i>%> 2> =>=> 0>]> print>(>list>)> |
>
>
Izhod
[0, 2, 4, 6, 8, 10]>
Matrika z uporabo seznamskega razumevanja
V tem primeru dodeljujemo cela števila od 0 do 2 do 3 vrstice matrike in jo natisnemo z uporabo seznamskega razumevanja.
Python
matrix>=> [[j>for> j>in> range>(>3>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Izhod
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]>
Razumevanje seznamov v primerjavi z zanko For
Obstaja več načinov za ponavljanje po seznamu. Vendar je najpogostejši pristop uporaba za zanka . Poglejmo si spodnji primer:
Python
# Empty list> List> => []> > # Traditional approach of iterating> for> character>in> 'Geeks 4 Geeks!'>:> >List>.append(character)> > # Display list> print>(>List>)> |
>
>
Izhod
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Zgoraj je implementacija tradicionalnega pristopa za ponavljanje skozi seznam, niz, tuple itd. Sedaj pa razumevanje seznama v Pythonu opravi isto nalogo in naredi program bolj preprost.
Razumevanje seznamov prevaja tradicionalni pristop ponovitve z uporabo za zanko v preprosto formulo, zaradi česar so enostavni za uporabo. Spodaj je prikazan pristop za ponavljanje po seznamu, nizu, tulu itd. z uporabo razumevanja seznama v Pythonu.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> 'Geeks 4 Geeks!'>]> > # Displaying list> print>(>List>)> |
>
>
Izhod
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Časovna analiza v seznamu Comprehensions in Loop
Razumevanje seznamov v Pythonu je učinkovitejše tako računsko kot glede prostora in časa kodiranja kot zanka for. Običajno so napisani v eni vrstici kode. Spodnji program prikazuje razliko med zankami in razumevanjem seznama glede na zmogljivost.
Python
python os listdir
# 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>))> |
>
>
Izhod
Time taken for_loop: 0.39 Time taken for list_comprehension: 0.35>
Iz zgornjega programa lahko vidimo, da je razumevanje seznamov precej hitrejše od zanke for.
Razumevanje ugnezdenih seznamov
Razumevanje ugnezdenih seznamov niso nič drugega kot razumevanje seznama znotraj drugega razumevanja seznama, ki je precej podobno ugnezdenim zankam for. Spodaj je program, ki izvaja ugnezdeno zanko:
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)> |
>
>
Izhod
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Zdaj je mogoče z uporabo razumevanja ugnezdenih seznamov enak izhod ustvariti v manj vrsticah kode.
Python
# Nested list comprehension> matrix>=> [[j>for> j>in> range>(>5>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Izhod
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Razumevanje seznamov in Lambda
Lambda izrazi niso nič drugega kot stenografske predstavitve funkcij Python. Uporaba seznamskih razumevanj z lambdo ustvari učinkovito kombinacijo. Poglejmo si spodnje primere:
10 od 60
V tem primeru na seznam vstavljamo številke od 10 do 50 in ga natisnemo.
Python
# using lambda to print table of 10> numbers>=> []> > for> i>in> range>(>1>,>6>):> >numbers.append(i>*>10>)> > print>(numbers)> |
>
>
Izhod
[10, 20, 30, 40, 50]>
Tukaj smo uporabili zanko for za tiskanje tabele 10.
Python
numbers>=> [i>*>10> for> i>in> range>(>1>,>6>)]> > print>(numbers)> |
>
>
Izhod
[10, 20, 30, 40, 50]>
Tu smo za prikaz tabele z 10 uporabili samo razumevanje seznama.
Python
# using lambda to print table of 10> numbers>=> list>(>map>(>lambda> i: i>*>10>, [i>for> i>in> range>(>1>,>6>)]))> > print>(numbers)> |
>
>
Izhod
[10, 20, 30, 40, 50]>
Nazadnje uporabljamo lambda + razumevanje seznama za prikaz tabele 10. Ta kombinacija je zelo uporabna za pridobivanje učinkovitih rešitev v manj vrsticah kode za kompleksne težave.
Pogojniki v razumevanju seznama
Razumevanju seznama lahko dodamo tudi pogojne izjave. Seznam lahko ustvarimo z uporabo obseg(), operaterji , itd. in cal uporabi tudi nekatere pogoje za seznam z uporabo izjava if .
Ključne točke
- Razumevanje seznama je učinkovito sredstvo za opisovanje in sestavljanje seznamov na podlagi trenutnih seznamov.
- Na splošno je razumevanje seznamov lahko in preprostejše od standardnih funkcij in zank za oblikovanje seznamov.
- Ne smemo pisati dolgih kod za razumevanje seznamov, da zagotovimo uporabniku prijazno kodo.
- Vsako razumevanje seznama je mogoče prepisati v zanki for, vendar v kontekstu interpretacije seznama vsake zanke for ni mogoče prepisati.
Spodaj je nekaj primerov, ki prikazujejo uporabo seznamskih razumevanj namesto tradicionalnega pristopa ponavljanja skozi iterable:
Razumevanje seznama Python z uporabo If-else.
V primeru preverjamo, da od 0 do 7, če je število sodo, potem vstavite Sodo število na seznam drugače vstavite Liho število na seznam.
Python
lis>=> [>'Even number'> if> i>%> 2> =>=> 0> >else> 'Odd number'> for> i>in> range>(>8>)]> print>(lis)> |
>
>
Izhod
['Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number']>
Ugnezdeni IF z razumevanjem seznama
V tem primeru na seznam vstavljamo števila, ki so večkratnik od 10 do 100, in ga natisnemo.
Python
lis>=> [num>for> num>in> range>(>100>)> >if> num>%> 5> =>=> 0> if> num>%> 10> =>=> 0>]> print>(lis)> |
>
>
Izhod
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]>
Prikažite kvadrat števil od 1 do 10
V tem primeru vstavimo kvadrat od 1 do 10 na seznam in natisnemo seznam.
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)> |
>
>
Izhod
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>
Prikaz transponiranja 2D-matrike
V tem primeru izvajamo prenos matrike z uporabo seznamskega razumevanja.
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)> |
>
>
Izhod
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]>
Preklopi med velikimi in malimi črkami vsakega znaka v nizu
V tem primeru preklopimo velike in male črke vsakega znaka v danem nizu z uporabo operatorja XOR s 32 in shranimo rezultat na seznam.
Python
# Initializing string> string>=> 'Geeks4Geeks'> > # Toggle case of each character> List> => list>(>map>(>lambda> i:>chr>(>ord>(i) ^>32>), string))> > # Display list> print>(>List>)> |
>
>
Izhod
['g', 'E', 'E', 'K', 'S', 'x14', 'g', 'E', 'E', 'K', 'S']>
Obrnite vsak niz v Tuple
V tem primeru obračamo nize v zanki for in jih vstavljamo na seznam ter natisnemo seznam.
Python
# Reverse each string in tuple> List> => [string[::>->1>]>for> string>in> (>'Geeks'>,>'for'>,>'Geeks'>)]> > # Display list> print>(>List>)> |
>
>
Izhod
['skeeG', 'rof', 'skeeG']>
Ustvarjanje seznama Tuples iz dveh ločenih seznamov
V tem primeru smo ustvarili dva seznama imena in starosti. Uporabljamo zip() pri razumevanju seznama in na seznam vstavimo ime in starost kot zbirko. Nazadnje natisnemo seznam tuplev.
Python
names>=> [>'G'>,>'G'>,>'g'>]> ages>=> [>25>,>30>,>35>]> person_tuples>=> [(name, age)>for> name, age>in> zip>(names, ages)]> print>(person_tuples)> |
>
>
Izhod:
[('G', 25), ('G', 30), ('g', 35)]> Prikažite vsoto števk vseh lihih elementov na seznamu.
V tem primeru smo ustvarili seznam in iščemo vsoto števk vsakega lihega elementa na seznamu.
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)> |
>
>
Izhod
[16, 3, 18, 18]>
Prednosti razumevanja seznama
- Časovno in prostorsko bolj učinkovito kot zanke.
- Zahtevajte manj vrstic kode.
- Pretvori iterativni stavek v formulo.
Vprašanja za vaje za razumevanje seznama Python
Spodaj sta dve vprašanji za vaje o razumevanju seznama Python. Zajeli smo osnovno kodo za razumevanje seznama za iskanje kocke števil in kodo za iskanje dolžine besede z uporabo razumevanja seznama in funkcije len().
niz v c++
Q1. Vprašanje za vajo kocke s številkami z uporabo razumevanja seznama
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>,>6>,>7>,>8>,>9>,>10>]> cube>=> [number>*>*>3> for> number>in> numbers]> print>(cube)> |
>
>
Izhod
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]>
Q2. Vprašanje za vajo Iskanje dolžine besede z razumevanjem seznama
Python
words>=> [>'apple'>,>'banana'>,>'cherry'>,>'orange'>]> word_lengths>=> [>len>(word)>for> word>in> words]> print>(word_lengths)> |
>
>
Izhod
[5, 6, 6, 6]>