Til Loop i Python
A for loop -sætning i Python iterates sekventielt over medlemmer af ethvert objekt, liste, streng osv. Sammenlignet med andre programmeringssprog er dens syntaks meget renere og kræver ikke manuelt at definere iterationstrin og starte iteration. Selvom der er måder at gøre dens adfærd på samme måde som andre programmeringssprog (vil ikke blive dækket i denne artikel). Du kan også udøve en vis kontrol over sløjfer ved at bruge udsagn som fortsæt, pause, pass osv. Nedenfor er et enkelt eksempel på for loop i Python:
tilxi rækkevidde(10):
Print(x)
For -løkken ovenfor vil udskrive ti tal, der starter fra 0 og slutter ved 9.
Liste forståelser
Listeforståelse er ikke andet end en stenografi / kortfattet måde at skrive multi-line for loops i en one-liner statement. Listeforståelseseksemplet herunder vil oprette en ny liste som [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ved at inkludere alle værdier af x i den.
tal= [xtilxi rækkevidde(10)]
Print (tal)
Bemærk, at listeforståelse altid opretter en ny liste og ikke ændrer originale iterabler, der bruges i udtrykket. Et typisk listeforståelsesudtryk skal have en for -klausul og kan efterfølges af if og ellers betingede udsagn. Uden at bruge en listeforståelse vil ovenstående eksempel blive skrevet på følgende måde:
tal= []
tilxi rækkevidde(10):
tal.Tilføj(x)
Print (tal)
Ydeevne og læsbarhed
Listeforståelser er hurtigere end for sløjfer. Medmindre du gentager flere hundrede tusinder af emner, vil du dog ikke bemærke større ydelsesforbedringer. Mens listeforståelse giver en kortfattet måde at skrive til loops, kan komplekse udtryk føre til dårlig læsbarhed af kode og øget verbositet. Det er vigtigt at holde koden læsbar, medmindre opnåelse af maksimal ydelse er en absolut nødvendighed for dit program.
Eksempel: Brug af listeforståelsessyntaks med ordbøger og sæt
En pythonordbog er en samling af elementer, der er defineret i nøgle-værdipar, mens et sæt er en samling af unikke værdier, hvor dubletter ikke er tilladt. Listeforståelser kan også bruges med Python -ordbøger og sæt. Syntaksen adskiller sig lidt, i stedet for at indpakke udtrykket i firkantede seler, skal du nu bruge krøllede seler. Du får også en ny ordbog / sæt objekt i stedet for en ny liste.
data= {'by':'new york', 'navn':'john doe'}
formateret_data= {k: v.titel() tiltil,vidata.genstande()}
Print (formateret_data)
Eksemplet ovenfor konverterer strengværdier til titelsag og opretter en ny ordbog kaldet formatted_data, hvis output vil være: {'city': 'New York', 'name': 'John Doe'}. Du kan også ændre ordbogen / sæt på stedet ved at angive den eksisterende ordbogsvariabel på venstre side.
data= {'by':'new york', 'navn':'john doe'}data= {k: v.titel() tiltil,vidata.genstande()}
Print (data)
Uden at bruge ordbogsforståelser ville koden se sådan ud:
data= {'by':'new york', 'navn':'john doe'}formateret_data= {}
tiltil,vidata.genstande():
formateret_data[til] =v.titel()
Print (formateret_data)
Da der ikke er nogen nøgle-værdipar i sæt, kan en sætforståelse defineres på samme måde som en listeforståelse. Den eneste forskel er brugen af krøllede seler.
Eksempel: Multiple For Loops in a List Comprehension
Listeforståelseseksemplet nævnt ovenfor er grundlæggende og bruger et enkelt til udsagn. Nedenfor er et eksempel, der bruger flere til sløjfer og en betinget if -sætning.
adjektiver= ['Disk', 'Eoan', 'Brændvidde', 'Kunstnerisk']dyr= ['Dingo', 'Hermine', 'Hullet', 'Bæver']
kodenavne= [x +''+ ogtilxiadjektivertilogidyrhvisog.starter med(x[0])]
Print (kodenavne)
Koden viser ['Disco Dingo', 'Eoan Ermine', 'Focal Fossa'] som output. De to for sløjfer går over tillægsord og dyrelister, og deres medlemmer slås sammen ved hjælp af et mellemrum, kun hvis det første bogstav i begge ord er det samme. Uden at bruge listeforståelser ville koden se sådan ud:
adjektiver= ['Disk', 'Eoan', 'Brændvidde', 'Kunstnerisk']dyr= ['Dingo', 'Hermine', 'Hullet', 'Bæver']
kodenavne= []
tilxiadjektiver:
tilogidyr:
hvisog.starter med(x[0]):
kodenavne.Tilføj(x +''+ og)
Print (kodenavne)
Eksempel: Listeforståelse med if-else-klausul
Nedenstående eksempel viser brug af if og ellers udsagn i listeforståelser.
nummerliste= [1, 2, 3, 4]en anden_liste= [5, 6, 7, 8]
resultat= [Sand hvis (x + y)%2 == 0 andet Falsk tilxinummerlistetilogien anden_liste]
Print (resultat)
Mens du går gennem to lister, kontrollerer listeforståelsen ovenfor, om summen af elementparret er lige eller ej. Hvis du kører koden ovenfor, vises [True, False, True, False, False, True, False, True, True, False, True, False, False, True, False, True] som output. Uden at bruge listeforståelse ville koden se sådan ud:
nummerliste= [1, 2, 3, 4]en anden_liste= [5, 6, 7, 8]
resultat= []
tilxinummerliste:
tilogien anden_liste:
hvis (x + y)%2 == 0:
resultat.Tilføj(Sand)
andet:
resultat.Tilføj(Falsk)
Print (resultat)
Konklusion
Listeforståelser giver en god måde at skrive rene og præcise loop -udsagn på. De kan dog hurtigt blive komplekse og vanskelige at forstå, hvis der bruges flere sløjfer og betingede udsagn. I sidste ende kommer det til komfortniveauet for en programmerer, men generelt er det en god idé at skrive eksplicit, læsbar og let at fejlsøge kode i stedet for overdreven brug af stenografier.