Inleiding tot het begrip van de Python-lijst
Het begrijpen van Python-lijsten is een andere manier om lijsten te maken met behulp van een iteratiebewerking. Het werkt op dezelfde manier als een lus, maar LC wordt specifiek gebruikt om lijsten terug te geven. Lijstbegrippen hebben uitdrukkingen tussen haakjes, zoals het maken van een normale lijst, de uitdrukking wordt uitgevoerd voor alle elementen.
Lijstbegrippen zijn erg handig in de gegevenswetenschap, waar men lijsten leest / kolomkolommen filtert / items uit lijsten etc. verwijdert. Hoewel we lussen en lambda-functies kunnen gebruiken om wat actie uit te voeren, biedt lijstbegrip een elegante en eenvoudige manier om hetzelfde weer te geven.
Lijstbegrippen kunnen worden gebruikt om methoden map (), reduce () en filter () te vervangen.
Lijstbegrip is als Set Theory van middelbare schoolklassen.
Voorbeeld:
( x: x is a natural number greater than 15 )
( x: x is a vowel in word 'Data Science', x is a vowel )
Laten we een lijstbegrip creëren voor de twee bovenstaande uitspraken.
(x for x in range(0, 20) if x>15) (x for x in 'Data Science' if x in ('a', 'e', 'i', 'o', 'u'))
Output:
(16, 17, 18, 19) ('a', 'a', 'i', 'e', 'e')Lijstbegrippen zijn gemakkelijk te begrijpen en te implementeren. In principe zijn deze gemaakt op tabellen. Er zijn drie dingen waarmee rekening moet worden gehouden bij het schrijven van de syntaxis voor het begrijpen van lijsten.
- Parameter voor uitgang
- Het iterabel
- Voorwaarden
De syntaxis kan twee van bovenstaande of drie van bovenstaande als syntaxis voor lijstbegrip hebben.
Syntaxis:
(output parameter | The Iterable)(output Parameter | The Iterable | Condition )
Voorbeelden van begrip van de Python-lijst
Hier zullen we bespreken hoe lijstbegrip te gebruiken met python. We zullen de voorbeelden op een andere manier bekijken omdat we het uitvoeren met behulp van for loop en dan zullen we hetzelfde creëren met behulp van lijstbegrippen.
Voorbeeld # 1: De perfecte vierkanten vinden
Hier zijn voorbeelden van perfecte vierkanten met verschillende onderstaande voorwaarden:
1. Met voor lus
for i in range(1, 30):
if int(i**0.5)==i**0.5:
print(i)
2. Gebruik van begrippenlijst
(x for x in range(1, 30) if int(x**0.5)==x**0.5)
Output:
Voorbeeld # 2: Krijg alleen medeklinkers uit een zin
Hier zullen we een willekeurige zin nemen en proberen we medeklinkers in de zin te krijgen als onze output.
1. For Loop gebruiken
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))
Output:
Met For Loop: wr stdyng lst cmprhnsns
2. Gebruik van lijstbegrip
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))
Output:
Lijst gebruiken Compr: wr stdyng lst cmprhnsns
Voorbeeld # 3: Een woordenboek maken van twee, in tegenstelling tot lijsten
Hier zijn voorbeelden van woordenboek met verschillende onderstaande voorwaarden:
1. For Loop gebruiken
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)))
Output:
FOR-lus resultaat: ('RDB': 'Aamire', 'Wanted': 'Salman', 'DDLG': 'SRK', 'Sholay': 'Amitabh', 'War': 'Hritik')
2. Gebruik van lijstbegrip
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)))
Output:
LC-resultaat: ('RDB': 'Aamire', 'Wanted': 'Salman', 'DDLG': 'SRK', 'Sholay': 'Amitabh', 'War': 'Hritik')
Voordelen van Python List Begrip
Lijstbegrippen voeren dezelfde taak uit, maar op een andere manier!
Lijstbegrip heeft veel voordelen ten opzichte van de lus en andere methoden. Enkele voordelen zijn:
- Lijstbegrippen zijn gemakkelijk te begrijpen en maken code elegant. We kunnen het programma met eenvoudige uitdrukkingen schrijven.
- Lijstbegrippen zijn veel sneller dan voor loop en andere methoden zoals een kaart. (Hetzelfde wordt in het onderstaande voorbeeld uitgelegd:
We nemen voorbeeld 1 als referentie en we berekenen de tijd die verschillende methoden nodig hebben om dezelfde functie uit te voeren. Eerst zullen we de tijd zien die wordt genomen door "for loop" en dan wordt de tijd genomen door de methode map () en ten slotte zullen we de tijd zien die nodig is voor het begrijpen van de lijst.
Een tabel toont de tijd die de verschillende technieken nodig hebben.
1. Voor lus
Voorbeeld met onderstaande lus:
Code:
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. Kaartmethode
Voorbeeld met de onderstaande kaartmethode:
Code:
def perf_square_map(x):
return map(lambda i: i**0.5==i**0.5, x)
%timeit perf_square_map(range(1, 30))
3. Lijstbegrippen
Voorbeeld met behulp van het onderstaande lijstbegrip:
Code:
def perf_square_lc(x):
return (i**0.5 == i**0.5 for i in x) %timeit perf_square_lc(range(1, 30))
Output:
| Methode | Tijd |
| For loop | 787 ns |
| Map () -methode | 518 ns |
| Lijstbegrippen | 276 ns |
Het is duidelijk dat de looptijd van het lijstbegrip 2, 85 keer sneller is dan voor loop en 1, 87 keer sneller dan de kaartmethode. Lijstbegrippen laten andere methoden met een grote marge achter. Er zou dan kunnen worden gespeculeerd, waarom gebruiken we dan niet gewoon LC op alle plaatsen en niet in loops? LC is in de meeste gevallen sneller en kan in bijna 80% gevallen lussen vervangen. Maar we kunnen lussen niet vervangen, in sommige gevallen hebben we een goed aantal voorwaarden en worden klassen in een lus genest. In deze gevallen kan het gebruik van LC behoorlijk omslachtig en ook niet haalbaar zijn. Het is beter om in dergelijke situaties voor lussen te gaan. Hoewel men lijstbegrip in lussen kan gebruiken om andere voor lussen te vervangen. Het verkort de uitvoeringstijd en handhaaft de gebruiksvriendelijkheid van de code.
- We kunnen meerdere voorwaarden in een lijstbegrip nestelen.
- LC kan meerdere variabele manipulatie uitvoeren.
- Het is niet nodig om een afzonderlijk commando op te geven om uitvoer te krijgen.
- Lijstbegrippen verminderen de complexiteit van de code.
- Lijstbegrippen zijn efficiënt.
Conclusie
Lijstbegrippen worden gebruikt voor het maken van lijsten uit het iteratieve proces. Lijstbegrippen zijn gemakkelijk te begrijpen / te implementeren en maken code elegant. Lijstbegrippen zijn compact en gebruiksvriendelijk.
We hebben de syntaxis voor lijstbegrippen besproken, samen met enkele goede inzichtelijke voorbeelden. Eindelijk schreven we één programma om de timing van elke methode te krijgen. We concludeerden dat de LC 2, 85 keer sneller is dan voor lus en 1, 87 keer sneller dan de map () -methode.
Aanbevolen artikelen
Dit is een gids voor het begrip van de Python-lijst. Hier bespreken we de voordelen van het begrijpen van de pythonlijst, samen met de syntaxis en voorbeelden met verschillende voorwaarden. U kunt ook de volgende artikelen bekijken voor meer informatie-
- Constructor in Java
- Sorteren op Java
- Constructor in Java
- JCheckBox in Java
- Handleiding voor sorteren in C # met voorbeelden
- Sorteerfunctie in Python met voorbeelden
- Lussen in VBScript met voorbeelden
- Voorbeelden om Checkbox in Bootstrap te implementeren