Introducere în Python List Comprehension
Înțelegerea Listelor Python este un alt mod de a crea liste folosind o operație de iterare. Funcționează la fel cum funcționează o buclă, dar LC este utilizat special pentru a returna listele. Înțelegerile listei au expresii în paranteze precum crearea unei liste normale, expresia se va executa pentru toate elementele.
Înțelegerile listelor sunt foarte utile în știința datelor, unde se pot citi liste / filtre de nume de coloană / eliminarea elementelor din liste etc. Deși putem folosi bucle și funcții lambda pentru a efectua unele acțiuni, înțelegerea listei oferă un mod elegant și simplu de a reprezenta același lucru.
Înțelegerile de listă pot fi utilizate pentru a substitui metodele map (), reduce () și filter ().
Înțelegerea listelor este ca teoria seturilor din clasele de liceu.
Exemplu:
( x: x is a natural number greater than 15 )
( x: x is a vowel in word 'Data Science', x is a vowel )
Să creăm o înțelegere a listei pentru cele două afirmații de mai sus.
(x for x in range(0, 20) if x>15) (x for x in 'Data Science' if x in ('a', 'e', 'i', 'o', 'u'))
ieşire:
(16, 17, 18, 19) ('a', 'a', 'i', 'e', 'e')Înțelegerile din listă sunt ușor de înțeles și de implementat. Practic acestea sunt create pe tabele. Există trei lucruri care trebuie luate în considerare în timp ce scrieți sintaxa pentru înțelegerea listelor.
- Parametru pentru ieșire
- Iterabilul
- Condiții
Sintaxa poate avea două dintre cele de mai sus sau 3 dintre cele de mai sus ca o sintaxă pentru înțelegerea listei.
Sintaxă:
(output parameter | The Iterable)(output Parameter | The Iterable | Condition )
Exemple de înțelegere a listelor Python
Aici vom discuta despre cum să utilizăm înțelegerea listelor folosind python. Vom vedea exemplele într-un mod diferit pe măsură ce îl vom rula folosind pentru buclă și apoi vom crea același folosind înțelegeri de listă.
Exemplul # 1: Găsirea pătratelor perfecte
Iată exemple de pătrate perfecte, cu condiții diferite, date mai jos:
1. Cu Loop
for i in range(1, 30):
if int(i**0.5)==i**0.5:
print(i)
2. Folosirea listelor Comprehensions
(x for x in range(1, 30) if int(x**0.5)==x**0.5)
ieşire:
Exemplul # 2: Obțineți numai consoane dintr-o propoziție
Aici vom lua o propoziție arbitrară și vom încerca să obținem consoane în propoziție ca ieșire a noastră.
1. Utilizarea pentru 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))
ieşire:
Cu For Loop: wr stdyng lst cmprhnsns
2. Folosirea listei Comprehension
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))
ieşire:
Utilizarea List Compr: wr stdyng lst cmprhnsns
Exemplul # 3: Crearea unui dicționar din două, spre deosebire de liste
Iată exemple de dicționar cu diferite condiții date mai jos:
1. Utilizarea pentru 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)))
ieşire:
Rezultat FOR-loop: ('RDB': 'Aamire', 'Wanted': 'Salman', 'DDLG': 'SRK', 'Sholay': 'Amitabh', 'War': 'Hritik')
2. Folosirea listei Comprehension
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)))
ieşire:
Rezultat LC: ('RDB': 'Aamire', 'Dorit': 'Salman', 'DDLG': 'SRK', 'Sholay': 'Amitabh', 'Război': 'Hritik')
Beneficiile înțelegerii listei Python
Înțelegerile din listă îndeplinesc aceeași sarcină, dar într-un mod diferit!
Înțelegerea listei are multe avantaje față de buclă și alte metode. Unele dintre beneficii sunt următoarele:
- Înțelegerile din listă sunt ușor de înțeles și fac ca codul să fie elegant. Putem scrie programul cu expresii simple.
- Înțelegerile din listă sunt mult mai rapide decât pentru buclă și alte metode precum o hartă. (Același lucru este explicat în exemplul de mai jos:
Vom lua exemplul 1 pentru referință și vom calcula timpul luat de diferite metode pentru a executa aceeași funcție. În primul rând, vom vedea timpul luat de „pentru buclă” și apoi timpul este luat prin metoda map () și în sfârșit vom vedea timpul luat de înțelegerile listei.
Un tabel prezintă timpul luat de diferitele tehnici.
1. Pentru Buclă
Exemplu de utilizare pentru bucla dată mai jos:
Cod:
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. Metoda hărții
Exemplu folosind metoda de hartă dată mai jos:
Cod:
def perf_square_map(x):
return map(lambda i: i**0.5==i**0.5, x)
%timeit perf_square_map(range(1, 30))
3. Enumerați înțelegerile
Exemplu folosind înțelegerea listei prezentată mai jos:
Cod:
def perf_square_lc(x):
return (i**0.5 == i**0.5 for i in x) %timeit perf_square_lc(range(1, 30))
ieşire:
| Metodă | Timp |
| Pentru buclă | 787 ns |
| Metoda Map () | 518 ns |
| Listă înțelegeri | 276 ns |
În mod clar, timpul de rulare al înțelegerii listei este de 2, 85 ori mai rapid decât pentru bucla și de 1, 87 ori mai rapid decât metoda hărții. Înțelegerile din listă lasă în urmă alte metode cu o marjă mare. Ar putea exista speculații de ce nu folosim LC în toate locurile și nu bucle? LC este mai rapid în majoritatea cazurilor și poate înlocui buclele în aproape 80% din cazuri. Dar nu putem înlocui buclele, există unele cazuri în care avem un număr bun de condiții, iar clasele sunt cuibărite într-o buclă. În aceste cazuri, utilizarea LC ar putea fi destul de greoaie și, de asemenea, nu este posibilă. Este mai bine să mergeți pentru bucle în astfel de situații. Deși se poate utiliza List List compre in pentru bucle pentru a înlocui altele pentru bucle. Acesta va reduce timpul de execuție, precum și menținerea ușurinței de utilizare a codului.
- Putem cuibări mai multe condiții într-o listă de înțelegere.
- LC poate efectua mai multe manipulări variabile.
- Nu este necesar să furnizați o comandă separată pentru a obține rezultate.
- Înțelegerile din listă reduc complexitatea codului.
- Înțelegerile din listă sunt eficiente.
Concluzie
Înțelegerile de listă sunt utilizate pentru crearea listelor din procesul iterativ. Înțelegerile din listă sunt ușor de înțeles / implementat și fac codul elegant. Înțelegerile din listă sunt compacte și ușor de utilizat.
Am discutat sintaxa pentru înțelegeri de listă, împreună cu câteva exemple bune. În cele din urmă, am scris un program pentru a obține calendarul de la fiecare metodă. Am ajuns la concluzia că LC este de 2, 85 ori mai rapid decât în buclă și de 1, 87 ori mai rapid decât metoda map ().
Articole recomandate
Acesta este un ghid pentru Înțelegerea listei Python. Aici vom discuta despre avantajele înțelegerii listelor piton împreună cu sintaxa și exemple cu diferite condiții. De asemenea, puteți consulta următoarele articole pentru a afla mai multe-
- Constructor în Java
- Sortare în Java
- Constructor în Java
- JCheckBox în Java
- Ghid pentru sortarea în C # cu exemple
- Funcția de sortare în Python cu exemple
- Bucle în VBScript cu exemple
- Exemple pentru a implementa caseta de selectare în Bootstrap