In dit artikel zullen we leren over het begrip van Python-lijsten en hoe u deze kunt gebruiken.
Lijstbegrip versus For Loop in Python
Stel dat we de letters van het woord willen scheiden humanen de letters als items van een lijst willen toevoegen. Het eerste dat in je opkomt, is het gebruik van for loop.
Voorbeeld 1: Itereren door een string met behulp van een lus
h_letters = () for letter in 'human': h_letters.append(letter) print(h_letters)
Wanneer we het programma uitvoeren, is de uitvoer:
('h', 'u', 'm', 'a', 'n')
Python heeft echter een eenvoudigere manier om dit probleem op te lossen met behulp van List Comprehension. Lijstbegrip is een elegante manier om lijsten te definiëren en aan te maken op basis van bestaande lijsten.
Laten we eens kijken hoe het bovenstaande programma kan worden geschreven met behulp van lijstbegrip.
Voorbeeld 2: Itereren door een string met behulp van lijstbegrip
h_letters = ( letter for letter in 'human' ) print( h_letters)
Wanneer we het programma uitvoeren, is de uitvoer:
('h', 'u', 'm', 'a', 'n')
In het bovenstaande voorbeeld wordt een nieuwe lijst toegewezen aan variabele h_letters, en lijst bevat de items van de itereerbare string 'human'. We noemen print()functie om de output te ontvangen.
Syntaxis van lijstbegrip
(uitdrukking voor item in lijst)
We kunnen nu identificeren waar lijstbegrip wordt gebruikt.
Als je het hebt opgemerkt, humanis dit een string, geen lijst. Dit is de kracht van lijstbegrip. Het kan identificeren wanneer het een string of een tupel ontvangt en eraan werken als een lijst.
U kunt dat doen met loops. Niet elke lus kan echter worden herschreven als lijstbegrip. Maar naarmate u leert en vertrouwd raakt met lijstbegrip, zult u merken dat u steeds meer loops vervangt door deze elegante syntaxis.
Lijstbegrip versus Lambda-functies
Lijstbegrip is niet de enige manier om aan lijsten te werken. Diverse ingebouwde functies en lambda-functies kunnen lijsten maken en wijzigen in minder regels code.
Voorbeeld 3: Lambda-functies gebruiken in List
letters = list(map(lambda x: x, 'human')) print(letters)
Wanneer we het programma uitvoeren, is de uitvoer
('h', 'u', 'm', 'a', 'n')
Lijstbegrip is echter meestal beter leesbaar voor mensen dan lambda-functies. Het is gemakkelijker te begrijpen wat de programmeur probeerde te bereiken wanneer lijstbegrip wordt gebruikt.
Conditionals in List Comprehension
Lijstbegrip kan voorwaardelijke verklaring gebruiken om bestaande lijst (of andere tuples) te wijzigen. We zullen een lijst maken die wiskundige operatoren, gehele getallen en bereik () gebruikt.
Voorbeeld 4: if gebruiken met lijstbegrip
number_list = ( x for x in range(20) if x % 2 == 0) print(number_list)
Wanneer we het bovenstaande programma uitvoeren, is de uitvoer:
(0, 2, 4, 6, 8, 10, 12, 14, 16, 18)
De lijst, number_list, wordt gevuld met de items in het bereik van 0-19 als de waarde van het item deelbaar is door 2.
Voorbeeld 5: geneste IF met lijstbegrip
num_list = (y for y in range(100) if y % 2 == 0 if y % 5 == 0) print(num_list)
Wanneer we het bovenstaande programma uitvoeren, is de uitvoer:
(0, 10, 20, 30, 40, 50, 60, 70, 80, 90)
Geef hier een overzicht van de bevattingschecks:
- Is y deelbaar door 2 of niet?
- Is y deelbaar door 5 of niet?
Als y aan beide voorwaarden voldoet, wordt y toegevoegd aan num_list.
Voorbeeld 6: if… else met lijstbegrip
obj = ("Even" if i%2==0 else "Odd" for i in range(10)) print(obj)
Wanneer we het bovenstaande programma uitvoeren, is de uitvoer:
('Even', 'Oneven', 'Even', 'Oneven', 'Even', 'Oneven', 'Even', 'Oneven', 'Even', 'Oneven')
Here, list comprehension will check the 10 numbers from 0 to 9. If i is divisible by 2, then Even is appended to the obj list. If not, Odd is appended.
Nested Loops in List Comprehension
Suppose, we need to compute the transpose of a matrix that requires nested for loop. Let’s see how it is done using normal for loop first.
Example 7: Transpose of Matrix using Nested Loops
transposed = () matrix = ((1, 2, 3, 4), (4, 5, 6, 8)) for i in range(len(matrix(0))): transposed_row = () for row in matrix: transposed_row.append(row(i)) transposed.append(transposed_row) print(transposed)
Output
((1, 4), (2, 5), (3, 6), (4, 8))
The above code use two for loops to find transpose of the matrix.
We can also perform nested iteration inside a list comprehension. In this section, we will find transpose of a matrix using nested loop inside list comprehension.
Example 8: Transpose of a Matrix using List Comprehension
matrix = ((1, 2), (3,4), (5,6), (7,8)) transpose = ((row(i) for row in matrix) for i in range(2)) print (transpose)
When we run the above program, the output will be:
((1, 3, 5, 7), (2, 4, 6, 8))
In above program, we have a variable matrix which have 4 rows and 2 columns.We need to find transpose of the matrix. For that, we used list comprehension.
**Note: The nested loops in list comprehension don’t work like normal nested loops. In the above program, for i in range(2) is executed before row(i) for row in matrix. Hence at first, a value is assigned to i then item directed by row(i) is appended in the transpose variable.
Key Points to Remember
- List comprehension is an elegant way to define and create lists based on existing lists.
- List comprehension is generally more compact and faster than normal functions and loops for creating list.
- However, we should avoid writing very long list comprehensions in one line to ensure that code is user-friendly.
- Onthoud dat elk lijstbegrip kan worden herschreven in for-lus, maar niet elke for-lus kan worden herschreven in de vorm van lijstbegrip.
