Python List Comprehension Tutorial

Wanneer je aan data science doet, kan het gebeuren dat je lijsten van lijsten wilt lezen, kolomnamen wilt filteren, klinkers uit een lijst wilt verwijderen of een matrix wilt flattenen. Je kunt hiervoor eenvoudig een lambda-functie of een for-loop gebruiken; zoals je weet zijn er meerdere manieren om dit aan te pakken. Een andere manier is met list comprehensions.

In deze tutorial gaan we in op dat laatste onderwerp:

• Je krijgt eerst een korte opfrisser over wat Python-lijsten zijn en hoe ze zich verhouden tot andere Python-datastructuren;
• Vervolgens duik je in Python list comprehensions: je leert meer over de wiskunde achter Python-lijsten, hoe je list comprehensions opbouwt, hoe je ze kunt herschrijven als for-loops of lambda-functies, ... Je leest hier niet alleen over, je maakt ook wat oefeningen!
• Als je de basis onder de knie hebt, is het tijd om je list comprehensions te verfijnen door er conditionals aan toe te voegen: je leert hoe je conditionals in list comprehensions opneemt en hoe je meerdere if-voorwaarden en if-else-statements afhandelt.
• Tot slot duik je in geneste list comprehensions om meerdere keren over lijsten te itereren.

Ben je ook geïnteresseerd om list comprehensions samen met iterators en generators aan te pakken? Bekijk dan de cursus Python Data Science Toolbox van DataCamp!

Python-lijsten

Tegenwoordig heb je waarschijnlijk al gewerkt met waarden van verschillende datatypes. Je hebt elke waarde in een aparte variabele opgeslagen: elke variabele stelt één waarde voor. In data science werk je echter vaak met veel datapunten, waardoor het lastig wordt om elke waarde in een eigen variabele te bewaren. In plaats daarvan sla je al deze waarden op in een Python-lijst.

Lijsten zijn een van de vier ingebouwde datastructuren in Python. Andere datastructuren die je misschien kent zijn tuples, dictionaries en sets. Een lijst in Python verschilt van bijvoorbeeld int of bool doordat het een samengesteld datatype is: je kunt waarden groeperen in lijsten. Die waarden hoeven zelfs niet van hetzelfde type te zijn: het kan een combinatie zijn van boolean-, string-, integer-, ... waarden.

Belangrijk om te weten is dat lijsten geordende verzamelingen van items of objecten zijn. Dit maakt lijsten in Python "sequence types", omdat ze zich gedragen als een sequentie. Dat betekent dat je erover kunt itereren; andere voorbeelden van sequenties zijn strings, tuples of sets.

Tip: wil je meer weten, je kennis testen of oefenen met Python-lijsten, ga dan door de meest voorkomende vragen over Python-lijsten hier.

Praktisch: je bouwt een lijst op met twee vierkante haken; binnen deze haken scheid je je waarden met komma's. Je kunt je lijst vervolgens aan een variabele toewijzen. De waarden die je in een Python-lijst zet, kunnen van elk datatype zijn, zelfs lijsten!

Bekijk het volgende voorbeeld van een lijst:

Tip: bouw je eigen lijst in de IPython-shell in het DataCamp Light-blok hierboven!

Python List Comprehension

Met de opfrissing van Python-lijsten vers in het geheugen zie je al snel dat lijsten definiëren en maken in Python een tijdrovend klusje kan zijn: alle waarden apart intypen kost best wat tijd en je maakt gemakkelijk fouten.

List comprehensions in Python worden als volgt opgebouwd:

list_variable = [x for x in iterable]

Maar hoe kom je tot deze formule-achtige manier om deze constructies in Python te bouwen en te gebruiken? Laten we wat dieper graven.

List Comprehension in Python: de wiskunde

Gelukkig heeft Python de oplossing: het biedt je een manier om een wiskundige notatie te implementeren om dit te doen: list comprehension.

Onthoud dat in de wiskunde veelgebruikte manieren om lijsten (of verzamelingen, of tuples, of vectoren) te beschrijven zijn:

S = {x² : x in {0 ... 9}}
V = (1, 2, 4, 8, ..., 2¹²)
M = {x | x in S and x even}

Met andere woorden, bovenstaande definities vertellen je eigenlijk het volgende:

• De sequentie S bevat waarden tussen 0 en 9 inclusief die tot de tweede macht worden verheven.
• De sequentie V bevat daarentegen de waarde 2 die tot een bepaalde macht wordt verheven. Voor het eerste element in de sequentie is dat 0, voor het tweede 1, enzovoort, tot en met 12.
• Tot slot bevat de sequentie M elementen uit sequentie S, maar alleen de even waarden.

Als de bovenstaande definities je hoofdpijn bezorgen, kijk dan naar de daadwerkelijke lijsten die deze definities zouden opleveren:

S = {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}
V = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096}
M = {0, 4, 16, 36, 64}

Je ziet duidelijk het resultaat van elke lijst en de bewerkingen die erin zijn beschreven!

Nu je wat van de wiskunde achter lijsten begrijpt, kun je de wiskundige notatie van het construeren van lijsten vertalen of implementeren in Python met list comprehensions! Kijk naar de volgende regels code:

Dit lijkt allemaal erg op de wiskundige definities die je net zag, toch?

Geen zorgen als je je nu een beetje verloren voelt; ook als je geen wiskundeknobbel hebt, zijn deze list comprehensions best eenvoudig als je de tijd neemt om ze te bestuderen. Kijk nog eens goed naar de Python-code in het codeblok hierboven.

Je ziet dat de code je vertelt dat:

• De lijst S is opgebouwd met de vierkante haken die je hierboven in de eerste sectie las. In die haken zie je een element x, dat tot de macht 10 wordt verheven. Nu moet je alleen nog weten voor hoeveel (en welke!) waarden je tot de tweede macht moet verheffen. Dit wordt bepaald in range(10). Gezien dit alles kun je afleiden dat je alle getallen van 0 tot en met 9 tot de tweede macht verheft.
• De lijst V bevat de basiswaarde 2, die tot een bepaalde macht wordt verheven. Net als eerder moet je nu weten welke macht of welk i precies wordt gebruikt. Je ziet dat i in dit geval deel uitmaakt van range(13), wat betekent dat je start bij 0 en doorgaat tot 12. Dit alles betekent dat je lijst 13 waarden zal hebben — die waarden zijn 2 tot de macht 0, 1, 2, ... tot en met 12.
• Tot slot bevat de lijst M elementen die deel uitmaken van S als —en alleen als— ze deelbaar zijn door 2 zonder rest. De modulo moet 0 zijn. Met andere woorden, de lijst M is opgebouwd uit de even waarden die in lijst S zijn opgeslagen.

Nu je dit zo uitgeschreven ziet, is het een stuk logischer, toch?

Samenvatting en oefenen

Kortom, je ziet dat er een paar elementen steeds terugkomen in al deze regels code:

• De vierkante haken, kenmerkend voor Python-lijsten;
• Het for-keyword, gevolgd door een variabele die een lijstitem symboliseert; en
• Het in-keyword, gevolgd door een sequentie (dat kan een lijst zijn!).

En dit resulteert in het stukje code dat je aan het begin van deze sectie zag:

list_variable = [x for x in iterable]

Nu is het jouw beurt om aan de slag te gaan met list comprehensions in Python! Laten we dicht bij de wiskundige lijsten blijven die je eerder hebt gezien:

List comprehension als alternatief voor...

List comprehension is een volledige vervanger voor for-loops, lambda-functies en de functies map(), filter() en reduce(). Bovendien is list comprehension voor sommigen zelfs makkelijker te begrijpen en in de praktijk te gebruiken! Je leest hier meer over in de volgende sectie!

Wil je meer weten over functies en lambda-functies in Python, bekijk dan onze Python Functions Tutorial.

For-loops

Zoals je wellicht weet, gebruik je for-loops om een codeblok een vast aantal keren te herhalen. List comprehensions zijn goede alternatieven voor for-loops, omdat ze compacter zijn. Bekijk het volgende voorbeeld dat begint met de variabele numbers, gedefinieerd als een bereik van 0 tot 10 (exclusief).

Onthoud dat het getal dat je doorgeeft aan de functie range() eigenlijk het aantal gehele getallen is dat je wilt genereren, natuurlijk beginnend bij nul. Dat betekent dat range(10) [0,1,2,3,4,5,6,7,8,9] zal teruggeven.

# Initialize `numbers`
numbers = range(10)

Als je nu een bewerking wilt uitvoeren op elk element in numbers, kan dat met een for-loop, zoals deze:

# Initialize `new_list`
new_list = []

# Add values to `new_list`
for n in numbers:
    if n%2==0:
        new_list.append(n**2)

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Dit is prima, maar bekijk nu het volgende voorbeeld van een list comprehension, waarmee je in essentie hetzelfde doet met een compactere notatie:

# Create `new_list` 
new_list = [n**2 for n in numbers if n%2==0]

# Print `new_list`
print(new_list)

[0, 4, 16, 36, 64]

Laten we het verschil in performance tussen de list comprehension en de for-loop bestuderen met een kleine test: je zet dit snel op met de timeit-bibliotheek, waarmee je kleine stukjes Python-code eenvoudig kunt timen. In dit geval test je de for-loop, die je voor het gemak in een functie power_two() stopt, en de exacte list comprehension die je hierboven hebt geformuleerd.

Let op dat je ook het aantal uitvoeringen meegeeft dat je wilt overwegen. In dit geval is dat ingesteld op 10000 in het argument number.

# Import `timeit`
import timeit

# Print the execution time
print(timeit.timeit('[n**2 for n in range(10) if n%2==0]', number=10000))

0.05234622399802902

# Define `power_two()` 
def power_two(numbers):
    for n in numbers:
        if n%2==0:
            new_list.append(n**2)
    return new_list

# Print the execution time 
print(timeit.timeit('power_two(numbers)', globals=globals(), number=10000))

0.07795589299712447

Let op dat je in dit laatste stukje code ook het argument globals toevoegt, waardoor de code binnen je huidige globale namespace wordt uitgevoerd. Dit is erg handig als je een User-Defined Function (UDF) hebt, zoals de functie power_two() in het bovenstaande voorbeeld. Als alternatief kun je ook een setup-parameter meegeven die een importstatement bevat. Je leest daar hier meer over.

Tip: bekijk DataCamp's tutorial Loops in Python voor meer informatie over loops in Python.

Lambda-functies met map(), filter() en reduce()

Lambda-functies worden ook wel "anonieme functies" of "functies zonder naam" genoemd. Dat betekent dat je dit type functies alleen gebruikt wanneer ze worden aangemaakt. Lambda-functies ontlenen hun naam aan het lambda-keyword in Python, dat wordt gebruikt om deze functies te declareren in plaats van het standaard def-keyword.

Je gebruikt deze functies meestal samen met de functies map(), filter() en reduce().

Hoe map() vervangen in combinatie met lambda-functies

Je kunt de combinatie van map() en een lambda-functie herschrijven zoals in het onderstaande voorbeeld:

# Initialize the `kilometer` list 
kilometer = [39.2, 36.5, 37.3, 37.8]

# Construct `feet` with `map()`
feet = map(lambda x: float(3280.8399)*x, kilometer)

# Print `feet` as a list 
print(list(feet))

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

Nu kun je deze combinatie van functies die de variabele feet definiëren eenvoudig vervangen door list comprehensions, met inachtneming van de onderdelen waarover je in de vorige sectie hebt gelezen:

• Begin met de vierkante haken.
• Voeg daarna de body van de lambda-functie toe binnen die vierkante haken: float(3280.8399)*x.
• Voeg vervolgens het for-keyword toe en zorg dat je het sequentie-element x herhaalt, waarnaar je al verwees door de body van de lambda-functie toe te voegen.
• Vergeet niet te specificeren waar x vandaan komt: voeg het keyword in toe, gevolgd door de sequentie waaruit je x haalt. In dit geval transformeer je de elementen van de lijst kilometer.

Als je dit allemaal doet, krijg je het volgende resultaat:

# Convert `kilometer` to `feet` 
feet = [float(3280.8399)*x for x in kilometer]

# Print `feet`
print(feet)

[128608.92408000001, 119750.65635, 122375.32826999998, 124015.74822]

filter() en lambda-functies naar list comprehensions

Nu je hebt gezien hoe eenvoudig je de functie map() in combinatie met een lambda-functie kunt omzetten, kun je ook code met de Python-functie filter() en lambda-functies aanpakken en eveneens herschrijven.

Bekijk het volgende voorbeeld:

# Map the values of `feet` to integers 
feet = list(map(int, feet))

# Filter `feet` to only include uneven distances 
uneven = filter(lambda x: x%2, feet)

# Check the type of `uneven`
type(uneven)

# Print `uneven` as a list
print(list(uneven))

[122375, 124015]

Om de regels code in het bovenstaande voorbeeld te herschrijven, kun je eigenlijk twee list comprehensions gebruiken, opgeslagen in zowel de variabelen feet als uneven.

Eerst herschrijf je de functie map(), die je gebruikt om de elementen van de lijst feet naar integers te converteren. Daarna pak je de functie filter() aan: je neemt de body van de lambda-functie, gebruikt de keywords for en in om x en feet logisch met elkaar te verbinden:

# Constructing `feet` 
feet = [int(x) for x in feet]

# Print `feet`
print(feet)

# Get all uneven distances
uneven = [x%2 for x in feet]

# Print `uneven`
print(uneven)

[128608, 119750, 122375, 124015]
[0, 0, 1, 1]

Reduce reduce() en lambda-functies in Python

Tot slot kun je ook lambda-functies die met de functie reduce() worden gebruikt, herschrijven naar compactere regels code. Bekijk het volgende voorbeeld:

# Import `reduce` from `functools` 
from functools import reduce

# Reduce `feet` to `reduced_feet`
reduced_feet = reduce(lambda x,y: x+y, feet)

# Print `reduced_feet`
print(reduced_feet)

[128608, 119750, 122375, 124015]
494748

Let op dat in Python 3 de functie reduce() is verplaatst naar het pakket functools. Je moet de module dus importeren om hem te gebruiken, zoals in het bovenstaande codevoorbeeld.

Het codeblok hierboven is vrij lang, niet?

Laten we dit stukje code herschrijven!

Wees voorzichtig! Je moet er rekening mee houden dat je y niet kunt gebruiken. List comprehensions werken slechts met één element tegelijk, zoals de x die je doorheen de voorbeelden van deze tutorial hebt gezien.

Hoe ga je dit oplossen?

In dit soort gevallen komen aggregerende functies zoals sum() van pas:

# Construct `reduced_feet`
reduced_feet = sum([x for x in feet])

# Print `reduced_feet`
print(reduced_feet)

494748

Let op dat, als je erover nadenkt, het gebruik van aggregerende functies bij het herschrijven van de functie reduce() in combinatie met een lambda-functie logisch is: het lijkt sterk op wat je in SQL doet wanneer je aggregerende functies gebruikt om het aantal records te beperken dat je terugkrijgt na het uitvoeren van je query. In dit geval gebruik je de functie sum() om de elementen in feet te aggregeren zodat je één definitieve waarde terugkrijgt!

Let op dat deze aanpak in SQL misschien niet even performant is, maar in Python is dit absoluut de juiste weg!

List comprehensions met conditionals

Nu je de basis van list comprehensions in Python begrijpt, is het tijd om de controlflow van je comprehensions aan te passen met behulp van conditionals.

# Define `uneven`
uneven = [x/2 for x in feet if x%2==0]

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Let op dat je het bovenstaande codeblok eenvoudig kunt herschrijven met een Python for-loop!

# Initialize and empty list `uneven` 
uneven = []

# Add values to `uneven` 
for x in feet:
    if x % 2 == 0:
        x = x / 2
        uneven.append(x)

# Print `uneven` 
print(uneven)

[64304.0, 59875.0]

Meerdere if-voorwaarden

Nu je begrijpt hoe je voorwaarden kunt toevoegen, is het tijd om de volgende for-loop om te zetten naar een list comprehension met conditionals.

divided = []

for x in range(100):
    if x%2 == 0 :
        if x%6 == 0:
            divided.append(x)

Wees voorzichtig, je ziet dat de volgende for-loop twee voorwaarden bevat! Denk goed na over hoe je dit gaat oplossen.

divided = [x for x in range(100) if x % 2 == 0 if x % 6 == 0]

print(divided)

[0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]

If-else-voorwaarden

Natuurlijk werk je veel vaker met conditionals die meer dan één voorwaarde bevatten. Je ziet inderdaad vaker if in combinatie met elif en else. Hoe ga je daarmee om als je je code wilt herschrijven?

Bekijk het volgende voorbeeld van zo'n complexere conditional in een for-loop:

[x+1 if x >= 120000 else x+5 for x in feet]

[128609, 119755, 122376, 124016]

Bekijk nu het volgende codeblok, dat een herstructurering is van het bovenstaande stukje code:

for x in feet:  
    if x >= 120000:
        x + 1
    else: 
        x+5

Je ziet dat dit in wezen dezelfde code is, maar herstructurerd: de laatste for x in feet initialiseert nu de for-loop. Daarna voeg je de voorwaarde if x >= 120000 toe en de regel code die je wilt uitvoeren als deze voorwaarde True is: x + 1. Als de voorwaarde in plaats daarvan False is, wordt het laatste stukje code in je list comprehension uitgevoerd: x+5.

Geneste list comprehensions

Naast conditionals kun je je list comprehensions ook aanpassen door ze te nesten binnen andere list comprehensions. Dit is handig wanneer je met lijsten van lijsten wilt werken: het genereren van lijsten van lijsten, het transponeren van lijsten van lijsten of het flattenen ervan naar gewone lijsten wordt bijvoorbeeld erg eenvoudig met geneste list comprehensions.

Bekijk het volgende voorbeeld:

list_of_list = [[1,2,3],[4,5,6],[7,8]]

# Flatten `list_of_list`
[y for x in list_of_list for y in x]

[1, 2, 3, 4, 5, 6, 7, 8]

Je wijst een vrij eenvoudige lijst-van-lijsten toe aan de variabele list_of_list. In de volgende regel voer je een list comprehension uit die een normale lijst teruggeeft. Wat er eigenlijk gebeurt, is dat je de listelementen (y) van de geneste lijsten (x) in list_of_list neemt en een lijst teruggeeft van die listelementen y die in x zitten.

Je ziet dat de meeste keywords en elementen die in het voorbeeld van de geneste list comprehension worden gebruikt, lijken op die uit de eenvoudige list comprehension-voorbeelden:

• Vierkante haken
• Twee for-keywords, gevolgd door een variabele die een item van de lijst-van-lijsten (x) symboliseert en een lijstitem van een geneste lijst (y); en
• Twee in-keywords, gevolgd door een lijst-van-lijsten (list_of_list) en een lijstitem (x).

De meeste componenten worden simpelweg twee keer gebruikt en je gaat één niveau hoger (of dieper, afhankelijk van je blik!).

Het is even wennen, maar eigenlijk best simpel, hè?

Laten we nu een ander voorbeeld bekijken, waarin je ziet dat je ook twee paar vierkante haken kunt gebruiken om de logica van je geneste list comprehension te veranderen:

matrix = [[1,2,3],[4,5,6],[7,8,9]]

[[row[i] for row in matrix] for i in range(3)]

[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

Oefen nu: herschrijf het bovenstaande codeblok naar een geneste for-loop. Heb je hints nodig voor deze oefening, ga dan naar een van de vorige secties van deze tutorial.

transposed = []

for i in range(3):
     transposed_row = []
     for row in matrix:
            transposed_row.append(row[i])
     transposed.append(transposed_row)

Je kunt geneste list comprehensions ook gebruiken wanneer je een lijst-van-lijsten wilt maken die eigenlijk een matrix is. Bekijk het volgende voorbeeld:

matrix = [[0 for col in range(4)] for row in range(3)]

matrix

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Tip: oefen je loop-skills in Python en herschrijf het bovenstaande codeblok naar een geneste for-loop!

Je vindt de oplossing hieronder.

for x in range(3):
    nested = []
    matrix.append(nested)
    for row in range(4):
        nested.append(0)

Wil je extra oefenen, probeer dan deze for-loop te vertalen naar een while-loop. Je vindt de oplossing hieronder:

x = 0
matrix =[]

while x < 3:
    nested = []
    y = 0
    matrix.append(nested)
    x = x+1
    while y < 4:
        nested.append(0)
        y= y+1

Tot slot is het goed om te weten dat je ook functies zoals int() kunt gebruiken om de entries in je feet-lijst naar integers te converteren. Door [int(x) for x in feet] in te kapselen binnen een andere list comprehension, bouw je eenvoudig een matrix of lijsten van je lijst:

[[int(x) for x in feet] for x in feet]

[[128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015],
 [128608, 119750, 122375, 124015]]

Beheers Python voor data science

Gefeliciteerd! Je bent aan het einde van deze tutorial gekomen, waarin je list comprehensions hebt aangepakt, een mechanisme dat vaak gebruikt wordt in Python voor data science. Nu je begrijpt hoe dit mechanisme werkt, ben je klaar om ook dictionary-, set-, ... comprehensions aan te pakken!

Vergeet niet dat je je Python-skills dagelijks kunt oefenen met de dagelijkse oefenmodus van DataCamp! Je vindt deze direct op je dashboard. Ken je de dagelijkse oefenmodus nog niet, lees er dan hier over! En bekijk hier de volledige catalogus met Python-cursussen van DataCamp.

Hoewel list comprehensions onze code beknopter kunnen maken, is het belangrijk om ervoor te zorgen dat onze uiteindelijke code zo leesbaar mogelijk is. Vermijd daarom hele lange enkele regels code, zodat onze code gebruiksvriendelijk blijft.