2.31. Iteraattorit ja generaattorit#

for -silmukka on tehnyt enemmän työtä kuin miltä näyttää. Tämä sivu käsittelee iteraattoriprotokollaa, jonka varassa se toimii, sekä yield -avainsanaa, jonka avulla voit rakentaa omia iteraattoreitasi.

2.31.1. Iteraattoriprotokolla#

Jokainen olio, jonka yli voidaan iteroida, toteuttaa kaksi metodia:

  • __iter__() – palauttaa iteraattorin olion alkioiden yli.

  • __next__() – iteraattorissa palauttaa seuraavan alkion tai nostaa poikkeuksen StopIteration, kun niitä ei ole enää.

Sisäänrakennettu iter() kutsuu metodia __iter__; next() kutsuu metodia __next__. Käy listaa läpi käsin:

it = iter([10, 20, 30])
print(next(it))    # 10
print(next(it))    # 20
print(next(it))    # 30
print(next(it))    # raises StopIteration
A for loop calls __iter__ once to get an iterator, then calls __next__ repeatedly until StopIteration ends the loop.

for on syntaksisokeria ilmaisulle ”kutsu __iter__ kerran, sitten silmukoi metodia __next__, kunnes StopIteration”.#

Mitä for x in items: todellisuudessa tekee:

_it = iter(items)
while True:
    try:
        x = next(_it)
    except StopIteration:
        break
    # ... loop body ...

Jokainen lista, monikko, merkkijono, sanakirja, joukko, tiedosto-olio ja generaattori toteuttaa jo metodit __iter__ ja __next__ – minkä vuoksi ne kaikki toimivat for -silmukan kanssa.

2.31.2. yield ja generaattorifunktiot#

Funktio, joka sisältää yield -lauseen, on generaattorifunktio. Sen kutsuminen ei suorita runkoa; se palauttaa generaattoriolion (iteraattorin), joka suorittaa rungon yhden yield -kohdan kerrallaan:

def count_up_to(n):
    i = 0
    while i < n:
        yield i
        i += 1

for value in count_up_to(3):
    print(value)

Tuloste:

0
1
2

Jokainen kutsu funktioon next() jatkaa funktiota seuraavaan yield -kohtaan asti, luovuttaa tuon arvon kutsujalle ja keskeytyy siihen. Paikallinen tila (tässä tapauksessa i) säilyy jatkamisten välillä.

Sequence diagram with two lifelines (caller and generator body). The caller calls count_up_to(3), which creates a generator without running the body. Each subsequent next() runs the body until the next yield, returns the yielded value, and pauses. The fourth next() falls off the end and raises StopIteration. The variable i is preserved across pauses.

next() suorittaa rungon seuraavaan yield -kohtaan asti, luovuttaa arvon takaisin ja keskeytyy. Paikallinen tila säilyy keskeytyksen yli.#

Generaattorit ovat helpoin tapa tuottaa sekvenssi laiskasti – listaa ei rakenneta, alkiot lasketaan vain kun kuluttaja niitä pyytää, ja funktio voi tuottaa alkioita loputtomiin niin halutessaan.

2.31.3. Laiskat liukuhihnat#

Generaattorit kytkeytyvät hyvin yhteen. Yhden generaattorin tuloste voi syöttää toista:

def numbers():
    i = 0
    while True:
        yield i
        i += 1

def squares(source):
    for x in source:
        yield x * x

pipeline = squares(numbers())

for v in pipeline:
    if v > 100:
        break
    print(v)

Arvot virtaavat liukuhihnan läpi yksi kerrallaan – ei välivaiheen listaa, ei muuttujaan numbers sisäänrakennettua ylärajaa, ja kuluttaja (for v in pipeline) päättää milloin lopettaa.

Three boxes left-to-right: numbers(), squares(source), and the for-v-in-pipeline consumer. Three cycles are drawn beneath. In each cycle, the consumer sends a pull request leftward to squares, which sends a pull leftward to numbers; numbers yields a value rightward to squares, which yields its squared value rightward to the consumer.

Jokainen next() kuluttajassa laukaisee yhden vedon ketjun läpi; arvot ovat olemassa vain kun jokin niitä pyytää.#

2.31.3.1. yield from#

Silmukka, joka vetää alkioita toisesta iteroitavasta ja tuottaa jokaisen niistä, on riittävän yleinen, että Python tarjoaa sille oikotien. Lauseke yield from iter tuottaa jokaisen arvon, jonka iteroitava tuottaa, järjestyksessä – aivan kuin generaattorissa olisi sisäänkirjoitettu for x in iter: yield x -silmukka:

def chain(*sources):
    for source in sources:
        yield from source

for v in chain([1, 2, 3], (4, 5), "abc"):
    print(v)

Tuloste:

1
2
3
4
5
a
b
c

yield from on täysin samanarvoinen kuin eksplisiittinen for -silmukka, vain lyhyempi, ja se välittää poikkeuksen StopIteration sisemmästä iteroitavasta ulompaan generaattoriin siististi – hyödyllistä ketjutettaessa useita generaattoreita peräkkäin.

2.31.3.2. Kun yield loppuu#

Generaattorifunktion lopusta putoaminen (tai eksplisiittiseen return -lauseeseen osuminen) nostaa poikkeuksen StopIteration automaattisesti. Sitä ei tarvitse nostaa käsin; ympäröivä for -silmukka näkee sen ja päättyy.

Käytä generaattoreita, kun tuottava koodi kirjoitetaan luontevasti silmukkana, jossa on muutama yield-kohta; käytä tavallista listamuodostinta, kun todella tarvitset koko sekvenssin muistissa.