Begrip van Lijstcomprehensies in Python 3

Inleiding

Listcomprehensies bieden een beknopte manier om lijsten te maken op basis van bestaande lijsten. Bij het gebruik van listcomprehensies kunnen lijsten worden opgebouwd door gebruik te maken van elk iterabel, inclusief strings en tuples.

Syntactisch bestaan listcomprehensies uit een iterabel met daaropvolgend een expressie gevolgd door een for-clausule. Hierop kunnen additionele for– of if-clausules volgen, dus kennis van for-lussen en conditionele statements zal u helpen listcomprehensies beter te begrijpen.

Lijstcomprehensies bieden een alternatieve syntaxis voor het maken van lijsten en andere opeenvolgende gegevenstypen. Hoewel andere methoden van iteratie, zoals for-lussen, ook kunnen worden gebruikt om lijsten te maken, worden lijstcomprehensies mogelijk verkozen omdat ze het aantal regels in uw programma kunnen beperken.

Vereisten

U moet Python 3 geïnstalleerd hebben en een programmeeromgeving hebben ingesteld op uw computer of server. Als u geen programmeeromgeving hebt ingesteld, kunt u verwijzen naar de installatie- en instelgidsen voor een lokale programmeeromgeving of voor een programmeeromgeving op uw server die geschikt is voor uw besturingssysteem (Ubuntu, CentOS, Debian, enz.)

Lijstcomprehensies

In Python worden lijstcomprehensies als volgt geconstrueerd:

list_variable = [x for x in iterable]

A list, or other iterable, is assigned to a variable. Additional variables that stand for items within the iterable are constructed around a for clause. The in keyword is used as it is in for loops, to iterate over the iterable.

Laten we eens kijken naar een voorbeeld dat een lijst maakt op basis van een string:

shark_letters = [letter for letter in 'shark']
print(shark_letters)

Hier wordt de nieuwe lijst toegewezen aan de variabele shark_letters, en letter wordt gebruikt om de items voor te stellen die in de iterabele string 'shark' zitten.

Om te bevestigen hoe de nieuwe lijst shark_letters eruitziet, roepen we deze op om te print() en ontvangen we de volgende uitvoer:

Output
['s', 'h', 'a', 'r', 'k']

De lijst die we hebben gemaakt met de list comprehension bestaat uit de items in de string 'shark', dat wil zeggen, één string voor elk letter.

List-comprehensies kunnen herschreven worden als for-lussen, hoewel niet elke for-lus herschreven kan worden als een lijst-comprehensie.

Laten we onze list comprehension die de shark_letters lijst hierboven heeft gemaakt, herschrijven als een for-lus. Dit kan ons helpen beter te begrijpen hoe de list comprehension werkt.

shark_letters = []

for letter in 'shark':
    shark_letters.append(letter)

print(shark_letters)

Bij het maken van een lijst met een for-lus, moet de variabele die aan de lijst is toegewezen worden geïnitialiseerd met een lege lijst, zoals in de eerste regel van ons codeblok. De for-lus doorloopt vervolgens het item, waarbij de variabele letter wordt gebruikt in de iterable string 'shark'. Binnen de for-lus wordt elk item binnen de string aan de lijst toegevoegd met de list.append(x)-methode.

Het herschrijven van de lijstcomprehensie als een for-lus geeft ons dezelfde uitvoer:

Output
['s', 'h', 'a', 'r', 'k']

Lijstcomprehensies kunnen worden herschreven als for-lussen, en sommige for-lussen kunnen worden herschreven als lijstcomprehensies om de code beknopter te maken.

Het gebruik van conditionals met lijstcomprehensies

Lijstcomprehensies kunnen conditionele verklaringen gebruiken om bestaande lijsten of andere opeenvolgende gegevenstypen te wijzigen bij het maken van nieuwe lijsten.

Laten we eens kijken naar een voorbeeld van een if-verklaring gebruikt in een lijstcomprehensie:

fish_tuple = ('blowfish', 'clownfish', 'catfish', 'octopus')

fish_list = [fish for fish in fish_tuple if fish != 'octopus']
print(fish_list)

De list comprehension gebruikt het tuple fish_tuple als basis voor de nieuwe lijst genaamd fish_list. De sleutelwoorden for en in worden gebruikt, zoals ze in de sectie hierboven waren, en nu wordt er een if-verklaring toegevoegd. De if-verklaring zegt om alleen die items toe te voegen die niet gelijk zijn aan de string 'octopus', dus de nieuwe lijst neemt alleen items van het tuple op die niet overeenkomen met 'octopus'.

Als we dit uitvoeren, zullen we merken dat fish_list dezelfde string-items bevat als fish_tuple, behalve het feit dat de string 'octopus' is weggelaten:

Output
['blowfish', 'clownfish', 'catfish']

Onze nieuwe lijst heeft dus elk item van het oorspronkelijke tuple, behalve de string die wordt uitgesloten door de voorwaardelijke verklaring.

We zullen nog een voorbeeld maken dat wiskundige operatoren, gehele getallen, en het range() sequentietype gebruikt.

number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)

De lijst die wordt gemaakt, number_list, zal worden gevuld met de gekwadrateerde waarden van elk item in het bereik van 0-9 als de waarde van het item deelbaar is door 2. De output is als volgt:

Output
[0, 4, 16, 36, 64]

Om iets meer te begrijpen van wat de lijstbegripsconstructie doet, laten we eens nadenken over wat er zou worden afgedrukt als we alleen x for x in range(10) zouden aanroepen. Ons kleine programma en de uitvoer zouden er dan als volgt uitzien:

number_list = [x for x in range(10)]
print(number_list)

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

Nu voegen we de voorwaardelijke verklaring toe:

number_list = [x for x in range(10) if x % 2 == 0]
print(number_list)

Output
[0, 2, 4, 6, 8]

De if-verklaring heeft de items in de uiteindelijke lijst beperkt tot alleen die items die deelbaar zijn door 2, waarbij alle oneven getallen worden weggelaten.

Ten slotte kunnen we de operator toevoegen om elk x kwadratisch te maken:

number_list = [x ** 2 for x in range(10) if x % 2 == 0]
print(number_list)

Dus elk van de getallen in de vorige lijst van [0, 2, 4, 6, 8] wordt nu gekwadrateerd:

Output
[0, 4, 16, 36, 64]

Je kunt ook geneste if-verklaringen repliceren met een lijstbegripsconstructie:

number_list = [x for x in range(100) if x % 3 == 0 if x % 5 == 0]
print(number_list)

Hier zal de lijstbegripsconstructie eerst controleren of het getal x deelbaar is door 3, en vervolgens controleren of x deelbaar is door 5. Als x aan beide eisen voldoet, wordt het afgedrukt, en de uitvoer is:

Output
[0, 15, 30, 45, 60, 75, 90]

Voorwaardelijke if-verklaringen kunnen worden gebruikt om te bepalen welke items uit een bestaande sequentie worden opgenomen bij het maken van een nieuwe lijst.

Geneste lussen in een lijstbegripsconstructie

Geneste lussen kunnen worden gebruikt om meerdere iteraties in onze programma’s uit te voeren.

Deze keer zullen we een bestaande geneste for-lusconstructie bekijken en stapsgewijs naar een lijstcomprehensie werken.

Onze code zal een nieuwe lijst maken die over 2 lijsten itereert en wiskundige bewerkingen uitvoert op basis daarvan. Hier is ons geneste for-lusblok:

my_list = []

for x in [20, 40, 60]:
	for y in [2, 4, 6]:
		my_list.append(x * y)

print(my_list)

Wanneer we deze code uitvoeren, krijgen we de volgende uitvoer:

Output
[40, 80, 120, 80, 160, 240, 120, 240, 360]

Deze code vermenigvuldigt de items in de eerste lijst met de items in de tweede lijst bij elke iteratie.

Om dit om te zetten in een lijstcomprehensie, zullen we elke regel code samenvoegen tot één regel, beginnend met de x * y-bewerking. Dit zal worden gevolgd door de buitenste for-lus, dan de innerlijke for-lus. We zullen een print()-verklaring toevoegen onder onze lijstcomprehensie om te bevestigen dat de nieuwe lijst overeenkomt met de lijst die we hebben gemaakt met ons geneste for-lusblok hierboven:

my_list = [x * y for x in [20, 40, 60] for y in [2, 4, 6]]
print(my_list)

Output
[40, 80, 120, 80, 160, 240, 120, 240, 360]

Onze lijstcomprehensie neemt de geneste for-lussen en maakt ze plat tot één regel code, terwijl nog steeds exact dezelfde lijst wordt gemaakt om aan de variabele my_list toe te wijzen.

Lijstcomprehensies bieden ons een beknopte manier om lijsten te maken, waardoor we verschillende regels code kunnen distilleren tot één enkele regel. Het is echter de moeite waard om in gedachten te houden dat de leesbaarheid van onze code altijd voorrang moet krijgen, dus wanneer een lijstcomprehensie te lang of onhandig wordt, is het misschien het beste om deze uit te splitsen in lussen.

Conclusie

Listcomprehensies stellen ons in staat om een lijst of andere sequentie om te zetten in een nieuwe lijst. Ze bieden een beknopte syntaxis om deze taak te voltooien, waardoor het aantal regels code wordt beperkt.

Listcomprehensies volgen de wiskundige vorm van verzamelaarsnotatie of verzamelingcomprehensie, dus ze kunnen bijzonder intuïtief zijn voor programmeurs met een wiskundige achtergrond.

Hoewel listcomprehensies onze code beknopter kunnen maken, is het belangrijk om ervoor te zorgen dat onze uiteindelijke code zo leesbaar mogelijk is, dus zeer lange enkele regels code moeten worden vermeden om ervoor te zorgen dat onze code gebruiksvriendelijk is.