Introduktion til Python-listeforståelse

Python-listeforståelse er en anden måde at oprette lister ved hjælp af en iterationsoperation. Det fungerer på samme måde som en løkke fungerer, men LC bruges specifikt til at returnere lister. Listeforståelser har udtryk inden i parentes som at oprette en normal liste, udtrykket udføres for alle elementer.

Listeforståelser er meget nyttige i datavidenskab, hvor man læser lister / filtrerer kolonnavne / fjerner elementer fra lister osv. Selvom vi kan bruge loops og lambda-funktioner til at udføre nogle handlinger, giver listeforståelse en elegant og enkel måde at repræsentere det samme.
Listeforståelser kan bruges til at erstatte kort (), reducere () og filter () metoder.
Listeforståelse er som sætteori fra gymnasieklasser.

Eksempel:

( x: x is a natural number greater than 15 )
( x: x is a vowel in word 'Data Science', x is a vowel )

Lad os oprette listeforståelse for de to ovenstående udsagn.

(x for x in range(0, 20) if x>15) (x for x in 'Data Science' if x in ('a', 'e', 'i', 'o', 'u'))

Produktion:

(16, 17, 18, 19) ('a', 'a', 'i', 'e', ​​'e')

Listeforståelser er lette at forstå og implementere. Grundlæggende oprettes disse på borde. Der er tre ting, der skal overvejes, mens du skriver syntaks for listerforståelser.

  1. Parameter til output
  2. Det gentagne
  3. Betingelser

Syntaks kan have to af ovenstående eller 3 af ovenstående som en syntaks til listeforståelse.

Syntaks:

(output parameter | The Iterable)
(output Parameter | The Iterable | Condition )

Eksempler på Python-listeforståelse

Her vil vi diskutere, hvordan man bruger listeforståelse ved hjælp af python. Vi vil se eksemplerne på en anden måde, da vi kører det ved hjælp af loop, og så vil vi oprette det samme ved hjælp af listeforståelser.

Eksempel 1: Find de perfekte firkanter

Her er eksempler på perfekte firkanter med forskellige betingelser givet nedenfor:

1. Med for Loop

for i in range(1, 30):
if int(i**0.5)==i**0.5:
print(i)

2. Brug af listeforståelser

(x for x in range(1, 30) if int(x**0.5)==x**0.5)

Produktion:

Eksempel 2: Få kun konsonanter fra en sætning

Her vil vi tage en vilkårlig sætning, og vi vil forsøge at få konsonanter i sætningen som vores output.

1. Brug til sløjfe

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))

Produktion:

Med For Loop: wr stdyng lst cmprhnsns

2. Brug af 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))

Produktion:

Brug af liste Compr: wr stdyng lst cmprhnsns

Eksempel 3: Oprettelse af en ordbog fra to i modsætning til lister

Her er eksempler på ordbog med forskellige betingelser givet nedenfor:

1. Brug til sløjfe

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)))

Produktion:

FOR-loop-resultat: ('RDB': 'Aamire', 'Wanted': 'Salman', 'DDLG': 'SRK', 'Sholay': 'Amitabh', 'War': 'Hritik')

2. Brug af 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)))

Produktion:

LC-resultat: ('RDB': 'Aamire', 'Wanted': 'Salman', 'DDLG': 'SRK', 'Sholay': 'Amitabh', 'War': 'Hritik')

Fordelene ved Python-listeforståelse

Listeforståelser udfører den samme opgave, men på en anden måde!

Listeforståelse har mange fordele i forhold til loopen og andre metoder. Nogle af fordelene er som følger:

  1. Listeforståelser er let at forstå og gøre koden elegant. Vi kan skrive programmet med enkle udtryk.
  2. Listeforståelser er langt hurtigere end for løkke og andre metoder som et kort. (Det samme forklares i nedenstående eksempel:

Vi tager eksempel 1 til reference, og vi beregner den tid, det tager med forskellige metoder til at udføre den samme funktion. Først vil vi se den tid, der er taget med "for loop", og derefter tages tiden ved hjælp af kort () -metoden, og til sidst vil vi se den tid, det tager med listeforståelser.

En tabel viser den tid, de forskellige teknikker tager.

1. For Loop

Eksempel ved hjælp af løkke angivet 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. Kortmetode

Eksempel ved hjælp af kortmetoden givet 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. Listeforståelser

Eksempel ved hjælp af nedenstående listeforståelse:

Kode:

def perf_square_lc(x):
return (i**0.5 == i**0.5 for i in x) %timeit perf_square_lc(range(1, 30))

Produktion:

MetodeTid
Til løkke787 ns
Kort () -metode518 ns
Listeforståelser276 ns

Det er klart, at køretid for listeforståelse er 2, 85 gange hurtigere end for løkke og 1, 87 gange hurtigere end kortmetoden. Listeforståelser efterlader andre metoder med stor margin. Der kan være spekulation, hvorfor bruger vi ikke bare LC alle steder og ikke løkker? LC er hurtigere i de fleste tilfælde, og det kan erstatte sløjfer i næsten 80% tilfælde. Men vi kan ikke udskifte sløjfer, der er nogle tilfælde, hvor vi har et godt antal betingelser, og klasser er indlejret i en løkke. I disse tilfælde kan brug af LC være ganske besværligt og ikke gennemførligt. Det er bedre at gå efter sløjfer i sådanne situationer. Selvom man kan bruge Listeforståelse i for løkker til at erstatte andre for sløjfer. Det reducerer udførelsestiden såvel som opretholder brugervenligheden af ​​koden.

  • Vi kan indlejre flere forhold i en listeforståelse.
  • LC kan udføre flere variabel manipulation.
  • Det er ikke nødvendigt at give en separat kommando for at få output.
  • Listeforståelser reducerer kodens kompleksitet.
  • Listeforståelser er effektive.

Konklusion

Listeforståelser bruges til at oprette lister fra den iterative proces. Listeforståelser er lette at forstå / implementere og gør koden elegant. Listeforståelser er kompakte og brugervenlige.

Vi har diskuteret syntaks for listeforståelser sammen med nogle gode indsigtsfulde eksempler. Til sidst skrev vi et program for at få timingen fra hver metode. Vi konkluderede, at LC er 2, 85 gange hurtigere end for loop, og 1, 87 gange hurtigere end kortmetoden ().

Anbefalede artikler

Dette er en guide til Python List Comprehension. Her diskuterer vi fordelene ved forståelse af pythonliste sammen med syntaks og eksempler med forskellige betingelser. Du kan også se på de følgende artikler for at lære mere-

  1. Konstruktør i Java
  2. Sorterer i Java
  3. Konstruktør i Java
  4. JCheckBox i Java
  5. Vejledning til sortering i C # med eksempler
  6. Sorteringsfunktion i Python med eksempler
  7. Loops i VBScript med eksempler
  8. Eksempler på implementering af afkrydsningsfelt i Bootstrap

Kategori: