Lijstbegrippen in Python

List comprehensions bieden u een manier van schrijven voor Loops meer bondig. Ze kunnen handig zijn als u nieuwe lijsten wilt maken van bestaande lijsten of iterables. U kunt bijvoorbeeld list comprehensions gebruiken om een ​​lijst met vierkanten uit een lijst met getallen te maken. U kunt ook een aantal voorwaarden in een lijst met getallen gebruiken, zodat de nieuwe lijst die u maakt een subset van de oorspronkelijke lijst is. 

Houd er rekening mee dat je niet alles kunt schrijven voor loop als een lijstbegrip. Nog een ding: de naam "lijstbegrippen" kan een beetje verwarrend zijn omdat het lijkt te suggereren dat de begrippen alleen bedoeld zijn om met lijsten te werken. In werkelijkheid wordt het woord "lijst" in list comprehensions gebruikt om aan te geven dat u lus over een iterabele in Python en het eindproduct zou een lijst zijn. 

Lussen en lijstbegrippen

Basislijstbegrippen die geen voorwaarden gebruiken, hebben de volgende vorm:

[ voor  in ]

Laten we beginnen met het schrijven van een heel elementaire voor loop om de eerste 15 veelvouden van 5 weer te geven. Eerst moet u een lege lijst maken. Vervolgens moet u een reeks getallen herhalen en ze vermenigvuldigen met 5. De nieuwe reeks getallen die u krijgt, zal bestaan ​​uit veelvouden van 5. 

veelvouden = [] voor n binnen bereik (1,16): multiples.append (n * 5) afdrukken (veelvouden) # [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75] 

Bovenstaande voor loop heeft in principe de volgende structuur: 

voor  in :  

Als je het vergelijkt met het formulier voor lijstbegrip dat je eerder hebt gelezen, kun je dat zien is n, is range (1,16), en is n * 5. Als u deze waarden in het lijstbegrip plaatst, krijgt u het volgende resultaat:

veelvouden = [n * 5 voor n binnen het bereik (1,15)] veelvouden # [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70]

Op dezelfde manier kun je ook een lijst met de kubus van gegeven nummers als volgt krijgen:

blokjes = [n ** 3 voor n binnen bereik (1,16)] afdrukken (blokjes) # [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 1331, 1728, 2197, 2744 , 3375]

Voorwaarden in List Begrippen

U kunt ook een als voorwaarde om bepaalde waarden uit de definitieve lijst te filteren. In dit geval heeft de lijstbegrip de volgende vorm:

[ voor  in  als ]

Een basisvoorbeeld van dit soort begrip zou zijn om alle even getallen in een bepaald bereik te krijgen. EEN voor lus om deze taak te doen ziet er als volgt uit:

evens = [] voor n binnen bereik (1,21): als n% 2 == 0: evens.append (n) afdrukken (evens) # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Hetzelfde kan ook worden bereikt door het volgende lijstbegrip te gebruiken:

evens = [n voor n in bereik (1,21) als n% 2 == 0] print (evens) # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Een meer gecompliceerd voorbeeld van het gebruik van list comprehensions zou een toevoeging zijn ... als ... anders ... conditionele uitdrukkingen erin. 

In dit geval zal de volgorde waarin u de instructies in het lijstbegrip opmaakt anders zijn dan gebruikelijk als voorwaarden. Wanneer je alleen een hebt als voorwaarde, de voorwaarde gaat naar het einde van het begrip. In het geval van een ... als ... anders ... uitdrukking, de posities van de voor loop en de conditionele expressie worden uitgewisseld. De nieuwe bestelling is:

[ als  anders  voor  in ]

Laten we beginnen met het schrijven van de uitgebreide woordenlijst ... als ... anders ...  conditionele expressie om vierkanten van even getallen en kubussen van oneven getallen in een bepaald bereik te krijgen.

squares_cubes = [] voor n binnen bereik (1,16): als n% 2 == 0: squares_cubes.append (n ** 2) else: squares_cubes.append (n ** 3) print (squares_cubes) # [1, 4, 27, 16, 125, 36, 343, 64, 729, 100, 1331, 144, 2197, 196, 3375]

De bovenstaande conditionele expressie heeft de volgende structuur:

voor  in : als :  anders: 

Door de corresponderende waarden op de juiste plaatsen te plaatsen, krijgt u het volgende overzicht:

squares_cubes = [n ** 2 if n% 2 == 0 else n ** 3 voor n binnen bereik (1,16)] print (squares_cubes) # [1, 4, 27, 16, 125, 36, 343, 64 729, 100, 1331, 144, 2197, 196, 3375]

Lijstbegrippen voor geneste lussen

U kunt ook geneste lussen gebruiken binnen een lijstbegrip. Er is geen limiet op het aantal voor loops die je in een lijstbegrip kunt plaatsen. Houd er echter rekening mee dat de volgorde van de lussen hetzelfde moet zijn in zowel de originele code als de lijstbegrip. U kunt ook een optionele toevoegen als staat na elk voor lus. Een lijstbegrip met genest voor loops hebben de volgende structuur:

[  voor  in  (optioneel als ) voor  in  (optioneel als ) voor  in  (optioneel als )… enzovoorts… ]

De volgende voorbeelden zouden alles duidelijker moeten maken. Er zijn twee geneste lussen en als we ze vermenigvuldigen, hebben we tafels voor vermenigvuldiging.

vermenigvuldigingen = [] voor i in bereik (1, 4): voor n binnen bereik (1, 11): multiplications.append (i * n) print (vermenigvuldigingen) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30] 

Deze zijn genest voor loops kunnen worden herschreven als:

voor  in : voor  in : 

Zodra u de lus in dit formulier hebt geschreven, is het converteren naar een lijstbegrip eenvoudig:

vermenigvuldigingen = [i * n voor i in bereik (1,4) voor n binnen bereik (1,11)] afdrukken (vermenigvuldigingen) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10 , 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30]

U kunt ook een soortgelijk geschreven lijstbegrip gebruiken om een ​​lijst met lijsten af ​​te vlakken. De buitenste voor lus itereert door individuele lijsten en slaat ze op in de variabele rij. Het innerlijk voor lus zal dan door alle elementen in de stroom heen gaan rij. Tijdens de eerste iteratie, de variabele rij heeft de waarde [1, 2, 3, 4]. De tweede lus itereert door deze lijst of rij en voegt al die waarden toe aan de definitieve lijst.

matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12],] flatten = [n voor rij in matrix voor n in rij] afdrukken (vlak maken ) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

Geneste lijstbevestigingen

Geneste lijstbegrippen kunnen lijken op lijstbegrippen met geneste lussen, maar ze zijn heel verschillend. In het eerste geval had je te maken met loops in loops. In dit geval zult u te maken hebben met lijstbegrippen binnen lijstbegrippen. Een goed voorbeeld van het gebruik van geneste lijstbegrippen is het creëren van een transponering van de matrix voor de vorige sectie.

Zonder een expressie van lijstbegrip, zult u er twee moeten gebruiken voor Loops om de transponering te creëren.

matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12],] transponeren = [] voor i in bereik (4): temp = [] voor rij in matrix: temp.append (rij [i]) transponeren.append (temp) afdrukken (transponeren) # [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

De buitenste lus itereert viermaal door de matrix omdat er vier kolommen in zitten. De binnenste lus itereert door de elementen in de huidige rij één index per keer en voegt deze toe aan een tijdelijke lijst met de naam temp. De temp lijst wordt vervolgens toegevoegd als een rij aan de getransponeerde matrix. In het geval van geneste lijstbegrippen komt de buitenste lus aan het einde en de binnenste lus komt aan het begin. 

Hier is de bovenstaande code in de vorm van een lijstbegrip:

matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12],] transponeren = [[rij [n] voor rij in matrix] voor n in bereik (4)] afdrukken (transponeren) # [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

Een andere manier om hiernaar te kijken is door de structuur van lijstbegrippen te beschouwen die de basis vervangen voor loops die je aan het begin van het artikel hebt geleerd.

[ voor  in ]

Als je het vergelijkt met het geneste lijstbegrip hierboven, zul je dat zien in dit geval is eigenlijk een andere lijstbegrip: [rij [n] voor rij in matrix]. Dit geneste lijstbegrip zelf is in de vorm van een basis voor lus.

Laatste gedachten

Ik hoop dat deze tutorial je heeft geholpen begrijpen welke lijstbegrippen zijn en hoe je ze kunt gebruiken in plaats van basis voor Loops om beknopte en iets snellere code te schrijven tijdens het maken van lijsten. 

Een ander ding dat u in gedachten moet houden, is de leesbaarheid van uw code. Het creëren van lijstbegrippen voor geneste lussen zal de code waarschijnlijk minder leesbaar maken. In dergelijke gevallen kunt u de lijstbegrip opsplitsen in meerdere regels om de leesbaarheid te verbeteren.

Aarzel niet om te zien wat we beschikbaar hebben voor de verkoop en voor onderzoek op Envato Market, en aarzel niet om vragen te stellen en uw waardevolle feedback te geven met behulp van de onderstaande feed.