För Loop i Python
A för loop -sats i Python iterates sekventiellt över medlemmar i ett objekt, lista, sträng etc. Jämfört med andra programmeringsspråk är dess syntax mycket renare och kräver inte manuellt definiera iterationssteg och starta iteration. Även om det finns sätt att göra dess beteende detsamma som andra programmeringsspråk (kommer inte att behandlas i den här artikeln). Du kan också utöva viss kontroll över slingor genom att använda påståenden som fortsätta, bryta, passera etc. Nedan följer ett enkelt exempel på för loop i Python:
förxi räckvidd(10):
skriva ut(x)
För -slingan ovan kommer att skriva ut tio nummer som börjar från 0 och slutar på 9.
Lista förståelser
Listförståelse är inget annat än ett stenografi / koncist sätt att skriva flera rader för slingor i ett en-liner-uttalande. Listförståelseexemplet nedan skapar en ny lista som [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] genom att inkludera alla värden för x i den.
tal= [xförxi räckvidd(10)]
skriva ut (tal)
Observera att listförståelse alltid skapar en ny lista och inte ändrar ursprungliga iterabler som används i uttrycket. Ett typiskt listförståelseuttryck måste ha en för -klausul och kan följas av ifall villkorade påståenden. Utan att använda en listförståelse kommer exemplet ovan att skrivas på följande sätt:
tal= []
förxi räckvidd(10):
tal.bifoga(x)
skriva ut (tal)
Prestanda och läsbarhet
Listförståelser är snabbare än för loopar. Men om du inte återkommer till hundratusentals objekt kommer du inte att märka några större prestandaförbättringar. Medan listförståelse ger ett kortfattat sätt att skriva för slingor, kan komplexa uttryck leda till dålig läsbarhet av kod och ökad verbositet. Det är viktigt att hålla koden läsbar, såvida inte att uppnå maximal prestanda är en absolut nödvändighet för ditt program.
Exempel: Använda listkompenseringssyntax med ordböcker och uppsättningar
En python-ordlista är en samling element som definieras i nyckel-värdepar medan en uppsättning är en samling unika värden där dubbletter inte är tillåtna. Listförståelser kan också användas med Python -ordböcker och uppsättningar. Syntaxen skiljer sig något, istället för att slå in uttrycket i fyrkantiga hängslen måste du nu använda lockiga hängslen. Du kommer också att få en ny ordbok / uppsatt objekt istället för en ny lista.
data= {'stad':'new york', 'namn':'john doe'}
formaterad_data= {k: v.titel() förtill,vidata.objekt()}
skriva ut (formaterad_data)
Exemplet ovan kommer att konvertera strängvärden till rubriker och skapa en ny ordlista som heter formatted_data, vars utdata kommer att vara: {'city': 'New York', 'name': 'John Doe'}. Du kan också ändra ordlistan / ställa in på plats genom att ange den befintliga ordlistans variabel på vänster sida.
data= {'stad':'new york', 'namn':'john doe'}data= {k: v.titel() förtill,vidata.objekt()}
skriva ut (data)
Utan att använda ordboksförståelser skulle koden se ut så här:
data= {'stad':'new york', 'namn':'john doe'}formaterad_data= {}
förtill,vidata.objekt():
formaterad_data[till] =v.titel()
skriva ut (formaterad_data)
Eftersom det inte finns några nyckel-värde-par i uppsättningar kan en uppsättningsförståelse definieras på samma sätt som en listförståelse. Den enda skillnaden är användningen av lockiga hängslen.
Exempel: Multiple For Loops in a List Comprehension
Listförståelseexemplet som nämns ovan är grundläggande och använder en enda för uttalande. Nedan finns ett exempel som använder flera för slingor och en villkorlig if -sats.
adjektiv= ['Disk', 'Eoan', 'Fokal', 'Listig']djur= ['Dingo', 'Hermelin', 'Gropen', 'Bäver']
kodnamn= [x +''+ ochförxiadjektivförochidjuromoch.börjar med(x[0])]
skriva ut (kodnamn)
Koden visar ['Disco Dingo', 'Eoan Ermine', 'Focal Fossa'] som utmatning. De två för slingor går över adjektiv och djurlistor och deras medlemmar sammanfogas med hjälp av ett mellanslag, bara om den första bokstaven i båda orden är densamma. Utan att använda listförståelser skulle koden se ut så här:
adjektiv= ['Disk', 'Eoan', 'Fokal', 'Listig']djur= ['Dingo', 'Hermelin', 'Gropen', 'Bäver']
kodnamn= []
förxiadjektiv:
förochidjur:
omoch.börjar med(x[0]):
kodnamn.bifoga(x +''+ och)
skriva ut (kodnamn)
Exempel: Listförståelse med if-else-klausul
Exemplet nedan visar användningen av if och else -påståenden i listförståelser.
nummer_lista= [1, 2, 3, 4]en annan_lista= [5, 6, 7, 8]
resultat= [Sann om (x + y)%2 == 0 annan Falsk förxinummer_listaförochien annan_lista]
skriva ut (resultat)
Medan du går igenom två listor kontrollerar listförståelsen ovan om summan av elementparet är jämn eller inte. Om du kör koden ovan visas [True, False, True, False, False, True, False, True, True, False, True, False, False, True, False, True] som utmatning. Utan att använda listförståelse skulle koden se ut så här:
nummer_lista= [1, 2, 3, 4]en annan_lista= [5, 6, 7, 8]
resultat= []
förxinumber_list:
förochianother_list:
om (x + y)%2 == 0:
resultat.bifoga(Sann)
annan:
resultat.bifoga(Falsk)
skriva ut (resultat)
Slutsats
Listförståelser är ett bra sätt att skriva rena och korta loop -satser. De kan dock snabbt bli komplexa och svåra att förstå om flera loopar och villkorliga uttalanden används. I slutändan kommer det till komfortnivån för en programmerare men i allmänhet är det en bra idé att skriva tydlig, läsbar och lätt att felsöka kod istället för att använda överdrivet kort.