Introduksjon til Python List Comprehension
Python List forståelse er en annen måte å lage lister ved å bruke en iterasjonsoperasjon. Det fungerer på samme måte som en sløyfe fungerer, men LC brukes spesielt til å returnere lister. Listeforståelser har uttrykk i parentes som å lage en normal liste, uttrykket vil kjøres for alle elementene.
Listeforståelser er veldig nyttige i datavitenskap, hvor man leser lister / filtrerer kolonnenavn / fjerner elementer fra lister osv. Selv om vi kan bruke looper og lambda-funksjoner for å utføre noen handlinger, gir listeforståelse en elegant og enkel måte å representere det samme.
Listeforståelser kan brukes til å erstatte metodene for kart (), reduksjon () og filter ().
Listeforståelse er som Set Theory fra videregående klasser.
Eksempel:
( x: x is a natural number greater than 15 )
( x: x is a vowel in word 'Data Science', x is a vowel )
La oss lage listeforståelse for de to uttalelsene ovenfor.
(x for x in range(0, 20) if x>15) (x for x in 'Data Science' if x in ('a', 'e', 'i', 'o', 'u'))
Produksjon:
(16, 17, 18, 19) ('a', 'a', 'i', 'e', 'e')Listeforståelser er enkle å forstå og implementere. I utgangspunktet er disse laget på bord. Det er tre ting du må vurdere når du skriver syntaks for forståelser av lister.
- Parameter for utgang
- Det iterable
- Forhold
Syntaksen kan ha to av de ovennevnte eller 3 av de ovennevnte som en syntaks for listeforståelse.
syntaks:
(output parameter | The Iterable)(output Parameter | The Iterable | Condition )
Eksempler på Python List Comprehension
Her vil vi diskutere hvordan du bruker listeforståelse ved bruk av python. Vi vil se eksemplene på en annen måte som vi vil bruke dem for for loop, og så vil vi lage det samme ved å bruke listeforståelser.
Eksempel 1: Finne de perfekte rutene
Her er eksempler på perfekte firkanter med forskjellige forhold gitt nedenfor:
1. Med for Loop
for i in range(1, 30):
if int(i**0.5)==i**0.5:
print(i)
2. Bruke listeforståelser
(x for x in range(1, 30) if int(x**0.5)==x**0.5)
Produksjon:
Eksempel 2: Få bare konsonanter fra en mening
Her vil vi ta en vilkårlig setning, og vi vil prøve å få konsonanter i setningen som vårt output.
1. Bruke For Loop
def consonants_for(sentence):
vowels = 'aeiou'
consonants = () for x in sentence:
if x not in vowels:
consonants.append(x)
return ''.join(consonants)
sentence = 'we are studying list comprehensions'
print("With For Loop : " + consonants_for(sentence))
Produksjon:
Med For Loop: wr stdyng lst cmprhnsns
2. Bruke listeforståelse
def consonants_lc(sentence):
vowels = 'aeiou'
return ''.join(( x for x in sentence if x not in vowels))
sentence = 'we are studying list comprehensions'
print("Using List Compr: " + consonants_lc(sentence))
Produksjon:
Bruke Liste Compr: wr stdyng lst cmprhnsns
Eksempel 3: Opprette en ordbok fra to, i motsetning til lister
Her er eksempler på ordbok med forskjellige forhold gitt nedenfor:
1. Bruke For Loop
def dict_for(keys, values):
dictionary = ()
for i in range(len(keys)):
dictionary(keys(i)) = values(i) return dictionary
Movie = ('RDB', 'Wanted', 'DDLG', 'Sholay', 'War', ) Actor = ('Aamire', 'Salman', 'SRK', 'Amitabh', 'Hritik') print("FOR-loop result: " + str(dict_for(Movie, Actor)))
Produksjon:
FOR-loop-resultat: ('RDB': 'Aamire', 'Wanted': 'Salman', 'DDLG': 'SRK', 'Sholay': 'Amitabh', 'War': 'Hritik')
2. Bruke listeforståelse
def dict_lc(keys, values):
return ( keys(i) : values(i) for i in range(len(keys)) )
Movie = ('RDB', 'Wanted', 'DDLG', 'Sholay', 'War', ) Actor = ('Aamire', 'Salman', 'SRK', 'Amitabh', 'Hritik') print("LC result : " + str(dict_lc(Movie, Actor)))
Produksjon:
LC-resultat: ('RDB': 'Aamire', 'Wanted': 'Salman', 'DDLG': 'SRK', 'Sholay': 'Amitabh', 'War': 'Hritik')
Fordelene med Python List Comprehension
Listeforståelser utfører den samme oppgaven, men på en annen måte!
Listeforståelse har mange fordeler i forhold til loopen og andre metoder. Noen av fordelene er som følger:
- Listeforståelser er enkle å forstå og gjør koden elegant. Vi kan skrive programmet med enkle uttrykk.
- Listeforståelser er mye raskere enn for looper og andre metoder som et kart. (Det samme blir forklart i eksempelet nedenfor:
Vi tar eksempel 1 som referanse, og vi vil beregne tiden det tar med forskjellige metoder for å utføre den samme funksjonen. Først vil vi se tiden for “for loop”, og så blir tiden tatt med kart () -metoden, og til slutt vil vi se tiden det tar av listeforståelser.
En tabell viser tiden det tar for de forskjellige teknikkene.
1. For Loop
Eksempel på bruk for loop gitt nedenfor:
Kode:
def perf_square(x):
output = () for i in x:
if int(i**0.5)==i**0.5:
output.append(i)
return output
%timeit perf_square(range(1, 30))
2. Kartmetode
Eksempel ved bruk av kartmetoden gitt nedenfor:
Kode:
def perf_square_map(x):
return map(lambda i: i**0.5==i**0.5, x)
%timeit perf_square_map(range(1, 30))
3. Liste forståelser
Eksempel ved bruk av listeforståelsen nedenfor:
Kode:
def perf_square_lc(x):
return (i**0.5 == i**0.5 for i in x) %timeit perf_square_lc(range(1, 30))
Produksjon:
| Metode | Tid |
| For sløyfe | 787 ns |
| Kart () -metode | 518 ns |
| Liste forståelser | 276 ns |
Det er tydelig at løpetiden av listeforståelsen er 2, 85 ganger raskere enn for sløyfen og 1, 87 ganger raskere enn kartmetoden. Listeforståelser etterlater andre metoder med stor margin. Det kan være spekulasjoner, hvorfor bruker vi ikke bare LC alle steder og ikke sløyfer? LC er raskere i de fleste tilfeller, og den kan erstatte løkker i nesten 80% tilfeller. Men vi kan ikke bytte ut løkker, det er noen tilfeller vi har noen gode antall forhold, og klasser hekker i en sløyfe. I disse tilfellene kan bruk av LC være ganske tungvint og ikke gjennomførbart. Det er bedre å gå etter løkker i slike situasjoner. Selv om man kan bruke Listeforståelse for løkker for å erstatte andre for løkker. Det vil redusere utførelsestiden, samt opprettholde brukervennligheten til koden.
- Vi kan hekke flere forhold i en listeforståelse.
- LC kan utføre flere variabel manipulasjoner.
- Det er ikke nødvendig å gi en egen kommando for å få utdata.
- Listeforståelser reduserer kompleksiteten til koden.
- Listeforståelser er effektive.
Konklusjon
Listeforståelser brukes til å lage lister fra den iterative prosessen. Listeforståelser er enkle å forstå / implementere og gjør koden elegant. Listeforståelser er kompakte og brukervennlige.
Vi har diskutert syntaks for listeforståelse sammen med noen gode innsiktsfulle eksempler. Til slutt skrev vi ett program for å få timingen fra hver metode. Vi konkluderte med at LC er 2, 85 ganger raskere enn for sløyfe og 1, 87 ganger raskere enn kart () -metoden.
Anbefalte artikler
Dette er en guide til Python List Comprehension. Her diskuterer vi fordelene med forståelse av pythonliste sammen med syntaks og eksempler med forskjellige forhold. Du kan også se på følgende artikler for å lære mer-
- Konstruktør i Java
- Sorterer i Java
- Konstruktør i Java
- JCheckBox i Java
- Veiledning for sortering i C # med eksempler
- Sorteringsfunksjon i Python med eksempler
- Looper i VBScript med eksempler
- Eksempler på implementering av avkrysningsrute i Bootstrap