Python-luettelon ymmärtäminen koostuu hakasulkeista, jotka sisältävät lausekkeen, joka suoritetaan kullekin elementille yhdessä for-silmukan kanssa toistaakseen jokaisen Python-luettelon elementin.
Esimerkki:
Python
numbers>=> [>12>,>13>,>14>,]> doubled>=> [x>*>2> for> x>in> numbers]> print>(doubled)> |
>
>
Lähtö
[24, 26, 28]>
Python-luettelon ymmärtämisen syntaksi
Syntaksi: uusi lista = [ lauseke (elementti) varten elementti sisään vanha lista jos kunto ]
Parametri:
lauseke : Edustaa toimintoa, jonka haluat suorittaa jokaiselle iteroitavan kohteelle. elementti : Termi muuttuja viittaa jokaiseen iterablesta otettuun arvoon. iteroitava : määritä elementtien sarja, jonka läpi haluat iteroida (esim. luettelo, monikko tai merkkijono). ehto : (Valinnainen) Suodatin auttaa päättämään, lisätäänkö elementti uuteen luetteloon vai ei.
Palata: Listan ymmärtämisen palautusarvo on uusi luettelo, joka sisältää muokatut elementit, jotka täyttävät annetut ehdot.
Python-luettelon ymmärtäminen tarjoaa paljon lyhyemmän syntaksin uuden luettelon luomiseen olemassa olevan luettelon arvojen perusteella.
Listan ymmärtäminen Python-esimerkissä
Tässä on esimerkki luettelon ymmärtämisen käyttämisestä luvun neliön löytämiseen Pythonissa.
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>]> squared>=> [x>*>*> 2> for> x>in> numbers]> print>(squared)> |
>
>
Lähtö
[1, 4, 9, 16, 25]>
Iterointi listan ymmärtämisellä
Tässä esimerkissä annamme luettelolle arvot 1, 2 ja 3 ja tulostamme luettelon käyttämällä luettelon ymmärtämistä.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> [>1>,>2>,>3>]]> > # Displaying list> print>(>List>)> |
>
>
Lähtö
[1, 2, 3]>
Parillinen luettelo luettelon ymmärtämisellä
Tässä esimerkissä tulostetaan parilliset luvut välillä 0–10 käyttämällä luettelon ymmärtämistä.
Python
list> => [i>for> i>in> range>(>11>)>if> i>%> 2> =>=> 0>]> print>(>list>)> |
>
>
Lähtö
[0, 2, 4, 6, 8, 10]>
Matriisi käyttäen Listan ymmärtämistä
Tässä esimerkissä annamme matriisin kokonaislukuja 0-2-3 riviä ja tulostamme sen List Comprehension -toiminnolla.
Python
matrix>=> [[j>for> j>in> range>(>3>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Lähtö
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]>
List Comprehensions vs For Loop
On olemassa useita tapoja iteroida luettelon läpi. Yleisin tapa on kuitenkin käyttää varten silmukka . Katsotaanpa alla olevaa esimerkkiä:
Python
# Empty list> List> => []> > # Traditional approach of iterating> for> character>in> 'Geeks 4 Geeks!'>:> >List>.append(character)> > # Display list> print>(>List>)> |
>
>
Lähtö
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Yllä on toteutettu perinteinen lähestymistapa iteroida listan, merkkijonon, tupelin jne. kautta. Nyt Pythonin listan ymmärtäminen tekee saman tehtävän ja tekee ohjelmasta myös yksinkertaisemman.
List Comprehensions kääntää perinteisen iteraatiomenetelmän käyttämällä silmukalle yksinkertaiseen kaavaan, mikä tekee niistä helppokäyttöisiä. Alla on tapa iteroida luetteloa, merkkijonoa, monikkoa jne. käyttämällä Pythonin luettelon ymmärtämistä.
Python
# Using list comprehension to iterate through loop> List> => [character>for> character>in> 'Geeks 4 Geeks!'>]> > # Displaying list> print>(>List>)> |
>
>
Lähtö
['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']>
Aika-analyysi luettelon ymmärtämisessä ja silmukassa
Pythonin listan ymmärtäminen on tehokkaampaa sekä laskennallisesti että koodaustilan ja ajan suhteen kuin a for silmukan. Yleensä ne kirjoitetaan yhdelle koodiriville. Alla oleva ohjelma kuvaa silmukoiden ja luettelon ymmärtämisen välisen eron suorituskyvyn perusteella.
Python
kasa lajitella
# 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>))> |
>
>
Lähtö
Time taken for_loop: 0.39 Time taken for list_comprehension: 0.35>
Yllä olevasta ohjelmasta voimme nähdä, että luettelon ymmärtäminen on melko nopeampaa kuin silmukan.
Sisäkkäiset listat
Sisäkkäiset listat ovat vain luettelon ymmärtäminen toisessa luettelon ymmärtämisessä, joka on melko samanlainen kuin sisäkkäisiä silmukoita varten. Alla on ohjelma, joka toteuttaa sisäkkäisen silmukan:
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)> |
>
>
Lähtö
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Nyt käyttämällä sisäkkäisten luetteloiden ymmärtämistä sama tulos voidaan luoda harvemmilla koodiriveillä.
Python
# Nested list comprehension> matrix>=> [[j>for> j>in> range>(>5>)]>for> i>in> range>(>3>)]> > print>(matrix)> |
>
>
Lähtö
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]>
Listaa ymmärrykset ja lambda
Lambda-ilmaisut ovat vain Python-funktioiden lyhennettyjä esityksiä. Listan ymmärtäminen lambdan kanssa luo tehokkaan yhdistelmän. Katsotaanpa alla olevia esimerkkejä:
Tässä esimerkissä lisäämme luetteloon numeroita 10-50 ja tulostamme sen.
Python
kromi osoitepalkki
# using lambda to print table of 10> numbers>=> []> > for> i>in> range>(>1>,>6>):> >numbers.append(i>*>10>)> > print>(numbers)> |
>
>
Lähtö
[10, 20, 30, 40, 50]>
Tässä olemme käyttäneet silmukkaa tulostaaksemme taulukon 10.
Python
numbers>=> [i>*>10> for> i>in> range>(>1>,>6>)]> > print>(numbers)> |
>
>
Lähtö
[10, 20, 30, 40, 50]>
Nyt olemme käyttäneet vain luettelon ymmärtämistä näyttääksemme taulukon 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)> |
>
>
Lähtö
[10, 20, 30, 40, 50]>
Lopuksi käytämme lambda + listan ymmärtämistä näyttämään taulukon 10. Tämä yhdistelmä on erittäin hyödyllinen tehokkaan ratkaisun saamiseksi pienemmillä koodiriveillä monimutkaisiin ongelmiin.
Ehdot luettelon ymmärtämisessä
Voimme myös lisätä ehdollisia lauseita listan ymmärtämiseen. Voimme luoda luettelon käyttämällä range(), operaattorit , jne. ja cal soveltavat myös joitain ehtoja luetteloon käyttämällä jos lausunto .
Avainkohdat
- Listan ymmärtäminen on tehokas tapa kuvailla ja muodostaa luetteloita nykyisten luetteloiden perusteella.
- Yleensä luettelon ymmärtäminen on kevyttä ja yksinkertaisempaa kuin tavalliset luettelonmuodostustoiminnot ja -silmukat.
- Emme saa kirjoittaa pitkiä koodeja luettelon ymmärtämiseen, jotta varmistetaan käyttäjäystävällinen koodi.
- Jokainen luettelon ymmärtäminen voidaan kirjoittaa uudelleen for-silmukalle, mutta listatulkinnan yhteydessä jokaista for-silmukkaa ei voida kirjoittaa uudelleen.
Alla on joitain esimerkkejä, jotka kuvaavat luettelon ymmärtämisen käyttöä perinteisen iteroitavan iteroitavan lähestymistavan sijaan:
Python-luetteloiden ymmärtäminen If-else-toiminnolla.
Esimerkissä tarkistamme, että 0-7, jos numero on parillinen, lisää Tasaluku Lisää luetteloon Pariton numero listalle.
Python
lis>=> [>'Even number'> if> i>%> 2> =>=> 0> >else> 'Odd number'> for> i>in> range>(>8>)]> print>(lis)> |
>
>
Lähtö
['Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number', 'Even number', 'Odd number']>
Sisäkkäinen IF luettelon ymmärtämisellä
Tässä esimerkissä lisäämme luetteloon numeroita, jotka ovat 10:n ja 100:n kerrannainen, ja tulostamme sen.
Python
lis>=> [num>for> num>in> range>(>100>)> >if> num>%> 5> =>=> 0> if> num>%> 10> =>=> 0>]> print>(lis)> |
>
>
Lähtö
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]>
Näytä numeroiden neliö väliltä 1-10
Tässä esimerkissä lisäämme neliön välillä 1–10 luetteloon ja tulostamme luettelon.
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)> |
>
>
Lähtö
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>
Näytön transponointi 2D-Matrixista
Tässä esimerkissä transponoimme matriisin käyttämällä luettelon ymmärtämistä.
lista lajittele java
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)> |
>
>
Lähtö
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]>
Vaihda merkkijonon jokaisen merkin kirjainkokoa
Tässä esimerkissä vaihdetaan tietyn merkkijonon jokaisen merkin kirjainkokoa käyttämällä XOR-operaattoria 32:lla ja tallennetaan tulos luetteloon.
Python
# Initializing string> string>=> 'Geeks4Geeks'> > # Toggle case of each character> List> => list>(>map>(>lambda> i:>chr>(>ord>(i) ^>32>), string))> > # Display list> print>(>List>)> |
>
>
Lähtö
['g', 'E', 'E', 'K', 'S', 'x14', 'g', 'E', 'E', 'K', 'S']>
Käännä jokainen merkkijono käänteisessä ketjussa
Tässä esimerkissä käännämme merkkijonoja silmukalle ja lisäämme ne luetteloon ja tulostamme luettelon.
Python
# Reverse each string in tuple> List> => [string[::>->1>]>for> string>in> (>'Geeks'>,>'for'>,>'Geeks'>)]> > # Display list> print>(>List>)> |
>
>
Lähtö
['skeeG', 'rof', 'skeeG']>
Tuple-luettelon luominen kahdesta erillisestä listasta
Tässä esimerkissä olemme luoneet kaksi luetteloa nimet ja iät. Meillä on käytössä postinumero() luettelon ymmärtämisessä ja lisäämme nimen ja iän luetteloon. Lopuksi tulostamme tuple-luetteloa.
Python
names>=> [>'G'>,>'G'>,>'g'>]> ages>=> [>25>,>30>,>35>]> person_tuples>=> [(name, age)>for> name, age>in> zip>(names, ages)]> print>(person_tuples)> |
>
>
Lähtö:
[('G', 25), ('G', 30), ('g', 35)]> Näytä luettelon kaikkien parittomien elementtien numeroiden summa.
Tässä esimerkissä olemme luoneet luettelon ja löydämme luettelon jokaisen parittoman elementin numerosumman.
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)> |
>
>
Lähtö
[16, 3, 18, 18]>
Listan ymmärtämisen edut
- Aika- ja tilaa säästävämpi kuin silmukat.
- Vaadi vähemmän koodirivejä.
- Muuntaa iteratiivisen lausunnon kaavaksi.
Python-luettelon ymmärtämisharjoituskysymyksiä
Alla on kaksi Python-listan ymmärtämiseen liittyvää harjoituskysymystä. Olemme käsitelleet perusluettelon ymmärtämiskoodin numerokuution löytämiseksi ja koodin sanan pituuden löytämiseksi käyttämällä luettelon ymmärtämistä ja len()-funktiota.
Q1. Lukukuution harjoituskysymys käyttäen luettelon ymmärtämistä
Python
numbers>=> [>1>,>2>,>3>,>4>,>5>,>6>,>7>,>8>,>9>,>10>]> cube>=> [number>*>*>3> for> number>in> numbers]> print>(cube)> |
>
>
Lähtö
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]>
Q2. Sananpituustehtävän kysymyksen löytäminen luettelon ymmärtämisen avulla
Python
words>=> [>'apple'>,>'banana'>,>'cherry'>,>'orange'>]> word_lengths>=> [>len>(word)>for> word>in> words]> print>(word_lengths)> |
>
>
Lähtö
[5, 6, 6, 6]>