For Loop i Python
A for loop -setning i Python iterates sekvensielt over medlemmer av ethvert objekt, liste, streng osv. Sammenlignet med andre programmeringsspråk, er syntaksen mye renere og krever ikke manuell definisjon av iterasjonstrinn og start iterasjon. Selv om det er måter å gjøre oppførselen den samme som andre programmeringsspråk (vil ikke bli dekket i denne artikkelen). Du kan også utøve litt kontroll over sløyfer ved å bruke utsagn som fortsette, bryte, passere osv. Nedenfor er et enkelt eksempel på for loop i Python:
tilxi område(10):
skrive ut(x)
For -løkken ovenfor vil skrive ut ti tall som starter fra 0 og slutter på 9.
Liste forståelser
Listeforståelse er ikke annet enn en stenografi / konsis måte å skrive flerlinje for sløyfer i en enliners uttalelse. Listeforståelseseksemplet nedenfor vil opprette en ny liste som [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ved å inkludere alle verdiene av x i den.
tall= [xtilxi område(10)]
skrive ut (tall)
Vær oppmerksom på 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 if og ellers betingede utsagn. Uten å bruke en listeforståelse, vil eksemplet ovenfor skrives på følgende måte:
tall= []
tilxi område(10):
tall.legge til(x)
skrive ut (tall)
Ytelse og lesbarhet
Listeforståelser er raskere enn for løkker. Men med mindre du gjentar flere hundre tusen elementer, vil du ikke legge merke til store ytelsesforbedringer. Selv om 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åelsessyntaks med ordbøker og sett
En pythonordbok er en samling elementer som er definert i nøkkelverdi-par mens et sett er en samling unike verdier der duplikater ikke er tillatt. Listeforståelser kan også brukes med Python -ordbøker og sett. Syntaksen er litt forskjellig, i stedet for å pakke inn uttrykket i firkantede seler, må du nå bruke krøllete seler. Du vil også få en ny ordbok / settobjekt i stedet for en ny liste.
data= {'by':'new york', 'Navn':'John Doe'}
formatert_data= {k: v.tittel() tiltil,vidata.elementer()}
skrive ut (formatert_data)
Eksemplet ovenfor vil konvertere strengverdier til tittelbokstaver og opprette en ny ordbok som heter formatted_data, hvis utgang vil være: {'city': 'New York', 'name': 'John Doe'}. Du kan også endre ordboken / settet på plass ved å spesifisere den eksisterende ordbokvariabelen på venstre side.
data= {'by':'new york', 'Navn':'John Doe'}data= {k: v.tittel() tiltil,vidata.elementer()}
skrive ut (data)
Uten å bruke ordbokforståelser, ville koden se slik ut:
data= {'by':'new york', 'Navn':'John Doe'}formatert_data= {}
tiltil,vidata.elementer():
formatert_data[til] =v.tittel()
skrive ut (formatert_data)
Siden det ikke er noen nøkkel-verdi-par i sett, kan en settforståelse defineres på samme måte som en listeforståelse. Den eneste forskjellen er bruken av krøllete seler.
Eksempel: Multiple For Loops in a List Comprehension
Listeforståelseseksemplet nevnt ovenfor er grunnleggende og bruker et enkelt for utsagn. Nedenfor er et eksempel som bruker flere for sløyfer og en betinget if -setning.
adjektiv= ['Disk', 'Eoan', 'Fokal', 'Kunstnerisk']dyr= ['Dingo', 'Hermelin', 'Gropen', 'Bever']
kodenavn= [x +''+ ogtilxiadjektivtilogidyrhvisog.begynner med(x[0])]
skrive ut (kodenavn)
Koden viser ['Disco Dingo', 'Eoan Ermine', 'Focal Fossa'] som utgang. De to for sløyfer går over adjektiver og dyrelister og medlemmene deres slås sammen ved hjelp av et mellomrom, bare hvis den første bokstaven i begge ordene er den samme. Uten å bruke listeforståelser, ville koden se slik ut:
adjektiv= ['Disk', 'Eoan', 'Fokal', 'Kunstnerisk']dyr= ['Dingo', 'Hermelin', 'Gropen', 'Bever']
kodenavn= []
tilxiadjektiv:
tilogidyr:
hvisog.begynner med(x[0]):
kodenavn.legge til(x +''+ og)
skrive ut (kodenavn)
Eksempel: Listeforståelse med if-else-klausul
Eksemplet nedenfor viser bruken av if og andre setninger i listeforståelser.
nummer_liste= [1, 2, 3, 4]en annen_liste= [5, 6, 7, 8]
resultat= [ekte hvis (x + y)%2 == 0 ellers Falsk tilxinummer_listetilogien annen_liste]
skrive ut (resultat)
Mens du går gjennom to lister, kontrollerer listeforståelsen ovenfor om summen av elementparet er jevn eller ikke. Å kjøre koden ovenfor viser deg [True, False, True, False, False, True, False, True, True, False, True, False, False, True, False, True] som utgang. Uten å bruke listeforståelse, ville koden se slik ut:
nummer_liste= [1, 2, 3, 4]en annen_liste= [5, 6, 7, 8]
resultat= []
tilxinumber_list:
tilogianother_list:
hvis (x + y)%2 == 0:
resultat.legge til(ekte)
ellers:
resultat.legge til(Falsk)
skrive ut (resultat)
Konklusjon
Listeforståelser gir en fin måte å skrive rene og konsise sløyfeuttalelser. Imidlertid kan de raskt bli komplekse og vanskelige å forstå hvis flere sløyfer 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 å bruke for mye stenografi.