Share
Listeforståelser gir deg en måte å skrive på til sløyfer mer konsistent. De kan være nyttige når du vil opprette nye lister fra eksisterende lister eller iterables. For eksempel kan du bruke listeforståelser for å lage en liste over kvadrater fra en liste med tall. På samme måte kan du også bruke noen betingelser på en liste over tall slik at den nye listen du lager, er en delmengde av den opprinnelige listen.
Husk at du ikke kan skrive hver til loop som en liste forståelse. En ting til og med: navnet "listforståelser" kan være litt forvirrende fordi det synes å foreslå at forståelsene bare er ment for å arbeide med lister. I virkeligheten er ordet "liste" i listeforståelser brukt til å indikere at du kan løse over noen iterable i Python og sluttproduktet ville være en liste.
Grunnleggende listeforståelser som ikke bruker noen betingelser, har følgende skjema:
[til i ]
La oss begynne med å skrive en veldig grunnleggende til sløyfe for å liste de første 15 multiplene på 5. Først må du opprette en tom liste. Deretter må du iterere over en rekke tall og multiplisere dem med 5. Den nye sekvensen av tall du får, vil bestå av multipler på 5.
multipler = [] for n i rekkevidde (1,16): multiples.append (n * 5) print (multipler) # [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75]
Ovennevnte til sløyfe har i utgangspunktet følgende struktur:
tili :
Hvis du sammenligner det med listen forståelsesskjemaet du leser tidligere, kan du se det n, området (1,16), og n * 5. Å sette disse verdiene i listen forståelse vil gi oss følgende resultat:
multipler = [n * 5 for n i rekkevidde (1,15)] multipler # [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70]
På samme måte kan du også få en liste med kuben av gitt tall slik:
kuber = [n ** 3 for n i rekkevidde (1,16)] utskrift (kuber) # [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 1331, 1728, 2197, 2744 , 3375]
Du kan også bruke en hvis betingelse for å filtrere ut bestemte verdier fra den endelige listen. I dette tilfellet tar listen forståelse følgende form:
[til i hvis ]
Et grunnleggende eksempel på denne typen forståelse ville være å få alle like tall i et gitt utvalg. EN til sløyfe for å gjøre denne oppgaven vil se slik ut:
evens = [] for n i rekkevidde (1,21): hvis n% 2 == 0: evens.append (n) print (evens) # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
Det samme kan også oppnås ved å bruke følgende listeforståelse:
evens = [n for n i rekkevidde (1,21) hvis n% 2 == 0] skriv ut (evens) # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
Et mer komplekst eksempel på bruk av listeforståelser vil være å legge til ... hvis ... annet ... betingede uttrykk i dem.
I dette tilfellet vil ordren der du legger ut setningene i listen forståelse være forskjellig fra vanlig hvis forhold. Når du bare har en hvis tilstanden, tilstanden går til slutten av forståelsen. Men i tilfelle av en ... hvis ... annet ... uttrykk, posisjonene til til sløyfe og det betingede uttrykket er vekslet. Den nye bestillingen er:
[hvis ellers til i ]
La oss begynne med å skrive det verbose ... hvis ... annet ... betinget uttrykk for å få firkanter av like tall og kuber av ulike tall i et gitt område.
squares_cubes = [] for n i rekkevidde (1,16): hvis n% 2 == 0: squares_cubes.append (n ** 2) annet: squares_cubes.append (n ** 3) print (squares_cubes) # [1, 4, 27, 16, 125, 36, 343, 64, 729, 100, 1331, 144, 2197, 196, 3375]
Ovennevnte betingede uttrykk har følgende struktur:
tili : hvis : ellers:
Å sette de tilsvarende verdiene på de riktige stedene vil gi deg følgende listeforståelse:
squares_cubes = [n ** 2 hvis n% 2 == 0 annet n ** 3 for n i rekkevidde (1,16)] print (squares_cubes) # [1, 4, 27, 16, 125, 36, 343, 64 , 729, 100, 1331, 144, 2197, 196, 3375]
Du kan også bruke nestede løkker innenfor en listeforståelse. Det er ingen grense på antall til sløyfer som du kan legge inn i en listeforståelse. Imidlertid må du huske på at rekkefølgen på løkkene skal være det samme i både den opprinnelige koden og listen forståelsen. Du kan også legge til en valgfri hvis tilstand etter hver til sløyfe. En liste forståelse med nestet til sløyfer vil ha følgende struktur:
[til i (valgfritt hvis ) for i (valgfritt hvis ) for i (valgfritt hvis )… og så videre… ]
Følgende eksempler skal gjøre alt tydeligere. Det er to nestede løkker, og multiplisere dem sammen gir oss multiplikasjonstabeller.
multiplikasjoner = [] for jeg i rekkevidde (1, 4): for n i rekkevidde (1, 11): multiplikasjoner.append (i * n) print (multiplikasjoner) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
Disse nestede til sløyfer kan skrives om som:
tili : for i :
Når du har skrevet løkken i dette skjemaet, er det enkelt å konvertere det til en listeforståelse:
multiplikasjoner = [i * n for jeg i rekkevidde (1,4) for n i rekkevidde (1,11)] print (multiplikasjoner) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10 , 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
Du kan også bruke en lignende skriftlig forståelse for å flette en liste over lister. Den ytre til loop iterates gjennom individuelle lister og lagrer dem i variabelen rad. Det indre til loop vil deretter iterere gjennom alle elementene i gjeldende rad. Under den første iterasjonen, variabelen rad har verdien [1, 2, 3, 4]. Den andre sløyfen iterates gjennom denne listen eller rad og legger alle disse verdiene til sluttlisten.
matrise = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12],] flat = [n for rad i matrise for n i rad] print ) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
Nestede listforståelser kan høres ut som listforståelser med nestede løkker, men de er veldig forskjellige. I det første tilfellet handlet du med løkker i looper. I dette tilfellet skal du håndtere listforståelser innenfor listeforståelser. Et godt eksempel på bruk av nestede listforståelser ville skape et transponering av matrisen for den forrige delen.
Uten et listeforståelsesuttrykk, må du bruke to til sløyfer for å lage transponeringen.
matrise = [[1, 2, 3, 4], [5, 6, 7, 8], [9,10,11,12],] transponere = [] for jeg i rekkevidde (4): temp = for rad i matrise: temp.append (rad [i]) transpose.append (temp) print (transponere) # [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
Ytre sløyfen iterates gjennom matrisen fire ganger fordi det er fire kolonner i den. Den indre sløyfen lukter gjennom elementene inne i den nåværende rad en indeks om gangen og legger den til en midlertidig liste som kalles temp. De temp Listen legges deretter til som en rad til den transponerte matrisen. Når det gjelder nestede listforståelser, kommer den ytre sløyfen på slutten, og den innerste sløyfen kommer i begynnelsen.
Her er koden ovenfor i form av en listeforståelse:
matrise = [[1, 2, 3, 4], [5, 6, 7, 8], [9,10,11,12],] transponere = [[rad [n] for rad i matrise] for n i rekkevidde (4)] print (transponere) # [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
En annen måte å se på dette er å vurdere strukturen av listforståelser som erstatter den grunnleggende til sløyfer som du lærte om i begynnelsen av artikkelen.
[til i ]
Hvis du sammenligner det med den nestede listforståelsen ovenfor, vil du se det [rad [n] for rad i matrise]. Denne nestede listforståelsen i seg selv er i form av en grunnleggende til sløyfe.
Jeg håper denne opplæringen hjalp deg med å forstå hvilken listeforståelse er og hvordan du bruker dem i stedet for grunnleggende til sløyfer for å skrive konsis og litt raskere kode mens du oppretter lister.
En annen ting du bør huske på er lesbarheten av koden din. Opprette listeforståelser for nestede løkker vil trolig gjøre koden mindre lesbar. I slike tilfeller kan du bryte ned listenforståelsen i flere linjer for å forbedre lesbarheten.
I tillegg, ikke nøl med å se hva vi har tilgjengelig for salg og for studier på Envato Market, og ikke nøl med å stille spørsmål og gi din verdifulle tilbakemelding ved hjelp av feedet under.
Accentsconagua