Inleiding tot lijstbegrippen Python
Begrip biedt een korte en eenvoudige manier om nieuwe reeksen te construeren met behulp van reeds gedefinieerde reeksen in Python. Deze reeksen kunnen Lijsten, Sets, Woordenboeken, etc. zijn. Lijstbegrip is een van de waardevolle functies van Python. Kort gezegd biedt List Comprehensions een manier om nieuwe lijsten te maken op basis van bestaande lijsten. Met andere woorden, Lijstbegrippen is een eenvoudige manier om een lijst te maken op basis van een aantal iterabele. Hier is een iterabel alles dat kan worden gebruikt om een lus te maken. Lijstbegrippen maken het mogelijk om een alternatieve syntaxis te gebruiken voor het maken van lijsten en andere sequentiële gegevenstypen in python. We zullen later bekijken hoe deze nuttig zijn. Er zijn 3 componenten van Lijstbegrip, deze zijn:
- Uitvoeruitdrukking: deze is optioneel en kan worden genegeerd.
- Iterable.
- Een variabele die leden van de iterabele vertegenwoordigt, wordt vaak Iterator-variabele genoemd.
Syntaxis en voorbeelden:
In python kunnen we Lijstbegrippen maken met behulp van de volgende syntaxis:
list_variable = (x for x in iterable)
Zoals u kunt zien in Lijstbegrippen, wordt een lijst toegewezen aan een variabele. Laten we eerst een voorbeeld bekijken, we kunnen eerst een methode overwegen om het kwadraat van een getal te vinden met behulp van een lus:
Code:
numbers = (2, 5, 3, 7) square = () for n in numbers:
square.append(n**2)
print(square)
Output:
Laten we nu overwegen hetzelfde te doen, maar met Lijstbegrippen in plaats van een lus:
Code:
numbers = (2, 5, 3, 7) square = (n**2 for n in numbers) print(square)
Output:
Hier kunt u zien dat vierkante haken "()" worden gebruikt om aan te geven dat de uitvoer van expressie in hen een lijst is.
Lijstbegrippen en Lambda-functies
Houd er rekening mee dat lijstbegrippen niet de enige manier zijn om lijsten te maken, Python heeft veel ingebouwde functies en lambdafuncties die kunnen worden gebruikt, zoals:
Code:
letters = list(map(lambda x: x, 'human'))
print(letters)
Output:
Hoewel dit in veel gevallen werkt, zijn lijstbegrippen beter in leesbaarheid en gemakkelijker te begrijpen door iemand die niet de programmeur van de code is.
Voorwaardelijke voorwaarden toevoegen aan lijstbegrippen
U bent vrij om alle voorwaardelijke benodigdheden in een lijst te gebruiken om de bestaande lijst te wijzigen. Laten we een voorbeeld bekijken dat voorwaardelijke waarden gebruikt:
Code:
numbers_list = ( x for x in range(20) if x % 2 == 0) print(numbers_list)
Output:
Hier is nog een voorbeeld:
Code:
numbers_list = (x for x in range(100) if x % 2 == 0 if x % 5 == 0) print(numbers_list)
Output:
Geneste loops gebruiken in lijstbegrippen
Indien nodig kunnen we geneste lussen gebruiken in lijstbegrippen, laten we eens kijken hoe we geneste lussen op deze manier kunnen gebruiken door de transpositie van een matrix te vinden:
Code:
transposedmatrix = () matrix = ((1, 2, 3, 4), (4, 5, 6, 8)) for i in range(len(matrix (0))):
transposedmatrix_row = () for row in matrix:
transposedmatrix_row.append(row(i))
transposedmatrix.append(transposedmatrix_row)
print(transposedmatrix)
Output:
Voorbeelden van lijstbegrippen Python
Hieronder staan de voorbeelden van Python voor lijstbegrippen:
Voorbeeld # 1 - Klinkers verwijderen uit een bepaalde zin
Code:
def eg_for(sentence):
vowels = 'aeiou'
filter_list = () for l in sentence:
if l not in vowels:
filter_list.append(l)
return ''.join(filter_list)
def eg_lc(sentence):
vowels = 'aeiou'
return ''.join(( X for X in sentence if X not in vowels))
Now, let's define the matrix, run the program and then check-out the results:
sentence = "hello from the other side"
print ("loop result: " + eg_for(sentence))
print ("LC result: " + eg_lc(sentence))
Output:
Voorbeeld # 2 - Namen van landen in kaart brengen met hun hoofdsteden
Code:
country = ( 'India', 'Italy', 'Japan' ) capital = ( 'Delhi', 'Rome', 'Tokyo' ) output_dict = ()
# Using loop for constructing dictionary
for (key, value) in zip(country, capital):
output_dict(key) = value
print("Output Dictionary using for loop:", output_dict)
Output:
Voordelen van lijstbegrippen Python
Je zou kunnen denken dat als Loops kunnen worden gebruikt om bijna alles te doen wat lijstbegrippen doen, waarom ze in de eerste plaats gebruiken? Het antwoord is snel en de tijd die nodig is om de taak uit te voeren en de hoeveelheid geheugen die nodig is. Wanneer een lijstbegrip wordt gemaakt, reduceren we al 3 coderegels in één en als het klaar is, is de code veel sneller dan wanneer we geconfronteerd worden met een lijstbegrip, wijst python eerst het geheugen voor de lijst toe en voegt vervolgens elementen erin toe. ook is het zonder twijfel een meer elegante en verfijnde manier om lijsten te maken die gebaseerd zijn op reeds bestaande lijsten.
Conclusie
Nu we enige ervaring hebben met het begrijpen van lijsten, is het gemakkelijk te begrijpen hoe deze ons toelaten om een lijst in een nieuwe lijst om te zetten. Deze hebben een eenvoudige syntaxis die de hoeveelheid werk beperkt die nodig is om een lijst te maken. Aangezien de syntaxis en structuur van lijstbegrippen in feite hetzelfde is als een notebouwer-notatie, worden deze snel een tweede natuur voor programmeurs en zorgen ze ervoor dat zodra de code wordt overgedragen aan een andere persoon om deze te onderhouden en uit te breiden, deze gemakkelijk te begrijpen is en werk met.
Aanbevolen artikel
Dit is een gids voor Python List List. Hier bespreken we lijstbegrippen en lambdafuncties samen met Code-implementatie en -output. U kunt ook onze andere voorgestelde artikelen doornemen voor meer informatie -
- Destructor in Python met voordelen
- Do While Loop in Python met Flowchart
- String Array in Python met methoden
- Wat is AWS Lambda-lagen?
- PL / SQL-gegevenstypen
- String Array in JavaScript
- Verschillende soorten SQL-gegevens met voorbeelden
- Volledige gids voor array van tekenreeksen