Python lijst notatie gebruiken

Bedrijf

In Python is het eenvoudig om de notatie list comprehensions te gebruiken bij het genereren van een nieuwe lijst.(List comprehensions)

In dit artikel zullen we eerst het volgende bespreken

  • Basistype van notatie van lijstbegrip
  • Notatie van lijstbegrip met voorwaardelijke vertakking door als
  • Combinatie met ternaire operatoren (if else-achtige verwerking)
  • zip(),enumerate()In combinatie met deze
  • geneste lijst inclusie notatie

Vervolgens zullen we de notatie van lijstbegrip uitleggen met voorbeeldcode.

  • set inclusie notatie(Set comprehensions)
  • woordenboek inclusie notatie(Dict comprehensions)
  • generatortype(Generator expressions)

Basistype van notatie van lijstbegrip

De notatie van lijstbegrip wordt als volgt geschreven.

[Expression for Any Variable Name in Iterable Object]

Het neemt elk element van een iterabel object zoals een lijst, tupel, of bereik met een willekeurige variabelenaam en evalueert het met een expressie. Een nieuwe lijst met het evaluatieresultaat als element wordt teruggegeven.

Er wordt een voorbeeld gegeven samen met een equivalent for statement.

squares = [i**2 for i in range(5)]
print(squares)
# [0, 1, 4, 9, 16]

squares = []
for i in range(5):
    squares.append(i**2)

print(squares)
# [0, 1, 4, 9, 16]

Hetzelfde proces kan worden gedaan met map(), maar de notatie list comprehension verdient de voorkeur vanwege de eenvoud en duidelijkheid.

Notatie van lijstbegrip met voorwaardelijke vertakking door als

Voorwaardelijke vertakking met if is ook mogelijk. Schrijf de if als volgt in de postfix.

[Expression for Any Variable Name in Iterable Object if Conditional Expression]

Alleen de elementen van het iterabel object waarvan de voorwaardelijke uitdrukking waar is, worden geëvalueerd door de uitdrukking, en een nieuwe lijst waarvan de elementen het resultaat zijn, wordt teruggegeven.

U kunt elke variabele naam gebruiken in de voorwaardelijke uitdrukking.

Er wordt een voorbeeld gegeven samen met een equivalent for statement.

odds = [i for i in range(10) if i % 2 == 1]
print(odds)
# [1, 3, 5, 7, 9]

odds = []
for i in range(10):
    if i % 2 == 1:
        odds.append(i)

print(odds)
# [1, 3, 5, 7, 9]

Hetzelfde proces kan worden gedaan met filter(), maar de notatie van lijstbegrip verdient de voorkeur vanwege de eenvoud en duidelijkheid.

Combinatie met ternaire operatoren (if else-achtige verwerking)

In het bovenstaande voorbeeld worden alleen die elementen verwerkt die aan de criteria voldoen, en die welke niet aan de criteria voldoen, worden uit de nieuwe lijst geweerd.

Als je het proces wilt laten afhangen van de voorwaarde, of als je elementen die niet aan de voorwaarde voldoen anders wilt verwerken, zoals in if else, gebruik je de ternaire operator.

In Python kan de ternaire operator als volgt worden geschreven

Value When True if Conditional Expression else Value When False

Dit wordt gebruikt in het uitdrukkingsdeel van de lijstbegripnotatie, zoals hieronder getoond.

[Value When True if Conditional Expression else Value When False for Any Variable Name in Iterable Object]

Er wordt een voorbeeld gegeven samen met een equivalent for statement.

odd_even = ['odd' if i % 2 == 1 else 'even' for i in range(10)]
print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

odd_even = []
for i in range(10):
    if i % 2 == 1:
        odd_even.append('odd')
    else:
        odd_even.append('even')

print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

Het is ook mogelijk om expressies te schrijven met willekeurige variabele namen voor de waar en onwaar waarden.

Als aan de voorwaarde is voldaan, wordt er iets gedaan, anders wordt de waarde van het oorspronkelijke iterabele object ongewijzigd gelaten.

odd10 = [i * 10 if i % 2 == 1 else i for i in range(10)]
print(odd10)
# [0, 10, 2, 30, 4, 50, 6, 70, 8, 90]

Combinatie met zip() en enumerate()

Nuttige functies die vaak gebruikt worden in het for statement zijn zip(), dat meerdere iterables combineert, en enumerate(), dat een waarde teruggeeft samen met zijn index.

Natuurlijk is het mogelijk om zip() en enumerate() te gebruiken met list comprehension notatie. Het is geen speciale syntaxis, en het is niet moeilijk als je kijkt naar de overeenkomst met het for statement.

Voorbeeld van zip().

l_str1 = ['a', 'b', 'c']
l_str2 = ['x', 'y', 'z']

l_zip = [(s1, s2) for s1, s2 in zip(l_str1, l_str2)]
print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]

l_zip = []
for s1, s2 in zip(l_str1, l_str2):
    l_zip.append((s1, s2))

print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]

Voorbeeld van opsommen().

l_enu = [(i, s) for i, s in enumerate(l_str1)]
print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]

l_enu = []
for i, s in enumerate(l_str1):
    l_enu.append((i, s))

print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]

Het idee is hetzelfde als voorheen bij het gebruik van if.

l_zip_if = [(s1, s2) for s1, s2 in zip(l_str1, l_str2) if s1 != 'b']
print(l_zip_if)
# [('a', 'x'), ('c', 'z')]

Elk element kan ook worden gebruikt om een nieuw element te berekenen.

l_int1 = [1, 2, 3]
l_int2 = [10, 20, 30]

l_sub = [i2 - i1 for i1, i2 in zip(l_int1, l_int2)]
print(l_sub)
# [9, 18, 27]

geneste lijst inclusie notatie

Net als het nesten van for-lussen, kan ook de list comprehension notatie genest worden.

[Expression for Variable Name 1 in Iterable Object 1
    for Variable Name 2 in Iterable Object 2
        for Variable Name 3 in Iterable Object 3 ... ]

Voor het gemak zijn regeleindes en inspringingen toegevoegd, maar deze zijn niet vereist voor de grammatica; ze kunnen op een enkele regel worden voortgezet.

Er wordt een voorbeeld gegeven samen met een equivalent for statement.

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

flat = [x for row in matrix for x in row]
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

flat = []
for row in matrix:
    for x in row:
        flat.append(x)

print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Het is ook mogelijk om meerdere variabelen te gebruiken.

cells = [(row, col) for row in range(3) for col in range(2)]
print(cells)
# [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]

Je kunt ook voorwaardelijke vertakkingen doen.

cells = [(row, col) for row in range(3)
         for col in range(2) if col == row]
print(cells)
# [(0, 0), (1, 1)]

Het is ook mogelijk om conditioneel te vertakken voor elk iterabel object.

cells = [(row, col) for row in range(3) if row % 2 == 0
         for col in range(2) if col % 2 == 0]
print(cells)
# [(0, 0), (2, 0)]

set inclusie notatie(Set comprehensions)

Door vierkante haakjes [] in de lijstbegripnotatie te veranderen in accolades {} ontstaat een verzameling (object van het type verzameling).

{Expression for Any Variable Name in Iterable Object}

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

woordenboek inclusie notatie(Dict comprehensions)

Woordenboeken (objecten van het type dict) kunnen ook worden gegenereerd met begripsnotatie.

{}, en specificeer de sleutel en waarde in het expressiedeel als sleutel: waarde.

{Key: Value for Any Variable Name in Iterable Object}

Elke expressie kan worden opgegeven voor sleutel en waarde.

l = ['Alice', 'Bob', 'Charlie']

d = {s: len(s) for s in l}
print(d)
# {'Alice': 5, 'Bob': 3, 'Charlie': 7}

Om een nieuw woordenboek te maken van een lijst van sleutels en waarden, gebruik je de functie zip().

keys = ['k1', 'k2', 'k3']
values = [1, 2, 3]

d = {k: v for k, v in zip(keys, values)}
print(d)
# {'k1': 1, 'k2': 2, 'k3': 3}

generatortype(Generator expressions)

Als vierkante haakjes [] in de lijstbegripnotatie worden gebruikt als ronde haakjes (), wordt een generator geretourneerd in plaats van een tupel. Dit wordt generator expressie genoemd.

Voorbeeld van notatie van lijstbegrip.

l = [i**2 for i in range(5)]

print(l)
# [0, 1, 4, 9, 16]

print(type(l))
# <class 'list'>

Voorbeeld van een generator expressie. Als je de generator afdrukt() zoals hij is, zal de inhoud niet worden afgedrukt, maar als je hem uitvoert met een for statement, kun je de inhoud krijgen.

g = (i**2 for i in range(5))

print(g)
# <generator object <genexpr> at 0x10af944f8>

print(type(g))
# <class 'generator'>

for i in g:
    print(i)
# 0
# 1
# 4
# 9
# 16

Generator expressies laten ook conditionele vertakkingen en nesten toe, gebruik makend van if en list comprehension notatie.

g_cells = ((row, col) for row in range(0, 3)
           for col in range(0, 2) if col == row)

print(type(g_cells))
# <class 'generator'>

for i in g_cells:
    print(i)
# (0, 0)
# (1, 1)

Als bijvoorbeeld een lijst met een groot aantal elementen wordt gegenereerd met behulp van list comprehension notatie en vervolgens wordt doorgelust met een for-instructie, zal de lijst met alle elementen aan het begin worden gegenereerd als list comprehension notatie wordt gebruikt. Aan de andere kant, als je een generator expressie gebruikt, worden elke keer dat de lus wordt herhaald, de elementen een voor een gegenereerd, waardoor de hoeveelheid gebruikt geheugen wordt verminderd.

Indien de generatoruitdrukking het enige argument van de functie is, kunnen de ronde haakjes () weggelaten worden.

print(sum([i**2 for i in range(5)]))
# 30

print(sum((i**2 for i in range(5))))
# 30

print(sum(i**2 for i in range(5)))
# 30

Wat de verwerkingssnelheid betreft, is de list comprehension notatie vaak sneller dan de generator notatie wanneer alle elementen worden verwerkt.

Echter, bij het beoordelen met all() of any(), bijvoorbeeld, wordt het resultaat bepaald wanneer false of true aanwezig is, dus het gebruik van generator expressies kan sneller zijn dan het gebruik van list comprehension notatie.

Er is geen tuple comprehension notatie, maar als je een generator expressie gebruikt als argument van tuple(), kun je een tuple genereren in de comprehension notatie.

t = tuple(i**2 for i in range(5))

print(t)
# (0, 1, 4, 9, 16)

print(type(t))
# <class 'tuple'>