Listeforståelser i Python
For sløyfe i Python
A for sløyfe -uttalelse i Python itererer i rekkefølge over medlemmer av ethvert objekt, liste, streng osv. Sammenlignet med andre programmeringsspråk, er syntaks mye renere og krever ikke manuelt å definere iterasjonstrinn og starte iterasjon. Selv om det er måter å gjøre oppførselen til det samme som andre programmeringsspråk (vil ikke bli dekket i denne artikkelen). Du kan også utøve litt kontroll over for løkker ved å bruke utsagn som fortsetter, bryte, pass osv. Nedenfor er et enkelt eksempel på for loop i Python:
for x i rekkevidde (10):trykk (x)
For sløyfen over vil skrive ut ti tall fra 0 og slutte kl. 9.
Liste over forståelse
Listeforståelse er ikke annet enn en kortfattet / kortfattet måte å skrive multi-line for løkker i en uttalelse på en linje. Eksemplet for listeforståelse nedenfor vil opprette en ny liste som [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ved å inkludere alle verdier av "x" i den.
tall = [x for x i rekkevidde (10)]utskrift (tall)
Merk at listeforståelse alltid oppretter en ny liste og ikke endrer originale iterabler som brukes i uttrykket. Et typisk listeforståelsesuttrykk må ha en "for" -klausul og kan følges av "hvis" og "ellers" betingede uttalelser. Uten å bruke en listeforståelse, vil eksemplet ovenfor bli skrevet på følgende måte:
tall = []for x i rekkevidde (10):
tall.vedlegg (x)
utskrift (tall)
Ytelse og lesbarhet
Listeforståelser er raskere enn for løkker. Imidlertid, med mindre du itererer over hundretusener av varer, vil du ikke merke store ytelsesforbedringer. Mens listeforståelse gir en kortfattet måte å skrive for løkker, kan komplekse uttrykk føre til dårlig lesbarhet av kode og økt verbositet. Det er viktig å holde koden lesbar, med mindre å oppnå maksimal ytelse er en absolutt nødvendighet for programmet ditt.
Eksempel: Bruke listeforståelser syntaks med ordbøker og sett
En Python-ordbok er en samling av elementer definert i nøkkelverdipar mens et sett er en samling av unike verdier der duplikater ikke er tillatt. Listeforståelser kan også brukes med Python -ordbøker og sett. Syntaksen skiller seg litt, i stedet for å pakke ut uttrykket i firkantede seler, må du nå bruke krøllete seler. Du vil også få et nytt ordbok / sett objekt i stedet for en ny liste.
Data = "City": "New York", "Navn": "John Doe"formatert_data = k: v.Tittel () For K, V i data.elementer ()
trykk (formatert_data)
Eksemplet ovenfor vil konvertere strengverdier til tittelesak og opprette en ny ordbok kalt “Formatered_data”, hvis utgang vil være: 'City': 'New York', 'Navn': 'John Doe'. Du kan også endre ordboken / settet på stedet ved å spesifisere den eksisterende ordboksvariabelen på venstre side.
Data = "City": "New York", "Navn": "John Doe"data = k: v.Tittel () For K, V i data.elementer ()
Print (data)
Uten å bruke ordbokforståelser, ville koden se slik ut:
Data = "City": "New York", "Navn": "John Doe"formatert_data =
for k, v i data.elementer ():
formatert_data [k] = v.tittel()
trykk (formatert_data)
Siden det ikke er noen nøkkelverdipar i sett, kan en fast forståelse defineres på samme måte som en listeforståelse. Den eneste forskjellen er bruk av krøllete seler.
Eksempel: Flere for løkker i en listeforståelse
Listeforståelseseksemplet nevnt ovenfor er grunnleggende og bruker en enkelt "for" -uttalelse. Nedenfor er et eksempel som bruker flere for løkker og en betinget "if" -uttalelse.
Adjektiver = ["Disco", "Eoan", "Focal", "Artful"]]Dyr = ["Dingo", "Ermine", "Fossa", "Beaver"]
kodenavn = [x + "" + y for x i adjektiver for y hos dyr hvis y.Startswith (x [0])]
trykk (kodenavn)
Koden viser ['Disco dingo', 'Eoan Ermine', 'Focal Fossa'] som utgang. De to for løkk. Uten å bruke listeforståelser, ville koden se slik ut:
Adjektiver = ["Disco", "Eoan", "Focal", "Artful"]]Dyr = ["Dingo", "Ermine", "Fossa", "Beaver"]
kodenavn = []
for x i adjektiver:
for y i dyr:
Hvis y.Startswith (x [0]):
kodenavn.vedlegg (x + "" + y)
trykk (kodenavn)
Eksempel: Listeforståelse med IF-Else Clause
Eksemplet nedenfor vil vise bruk av IF og ellers uttalelser i listeforståelser.
nummer_list = [1, 2, 3, 4]en annen_list = [5, 6, 7, 8]
Resultat = [True If (x + y) % 2 == 0 annet falsk for x i nummer_list for y i en annen_list]
trykk (resultat)
Mens du slår gjennom to lister, sjekker listeforståelsen over om summen av elementene er jevn eller ikke eller ikke. Å kjøre koden over vil vise deg [sann, falsk, sann, falsk, falsk, sann, falsk, sann, sann, falsk, sann, falsk, falsk, sann, falsk, sann] som utgang. Uten å bruke listeforståelse, ville koden se slik ut:
nummer_list = [1, 2, 3, 4]en annen_list = [5, 6, 7, 8]
resultat = []
for x i nummer_liste:
for y i en annen_liste:
if (x + y) % 2 == 0:
resultat.vedlegg (sant)
ellers:
resultat.vedlegg (falsk)
trykk (resultat)
Konklusjon
Listeforståelser gir en fin måte å skrive rene og konsise sløyfeuttalelser. Imidlertid kan de raskt få komplekse og vanskelige å forstå om flere løkker og betingede utsagn brukes. Til slutt kommer det til komfortnivået til en programmerer, men generelt er det en god idé å skrive eksplisitt, lesbar og lett å feilsøke kode i stedet for i overdreven bruk.