Loeng 7: Generaator, iteraator, laisk itereerimine, lausendid yield ja yield from, sisseehitatud funktsioonid iter ja next, generaatoriavaldis ehk generaatori lühiesitus

Viimati uuendatud 13.10.2025.

---

Koodinäited

1  Laisk itereerimine (lazy iteration)

Laisad iteraatorid lubavad töödelda suuri koguseid andmeid ilma neid korraga salvestades. Pythoni generaatorid ja iteraatorid väljastavad tulemusi, vajadusel kasvõi lõpmatult palju kordi. Iteraat luuakse ja väljastatakse ainult siis kui seda küsitakse.

Tihti polegi võimalust salvastada kõiki vajaminevaid andmeid. Nt. arvuti parooli tähemärkide kombinatsioonide arv. Tähemärkide ja numbrite kõikvõimalike lõpliku pikkusega permutatsioonide loendit pole põhimõtteliselt võimalik arvutisse salvestada. Neid saab aga ükshaaval luua.

2  Generaator, generaatorfunktsioon ja lausend yield

Generaator on spetsiaalne funktsioon, mille nimeruum säilib väärtuse väljastamisel. Lisaks säilivad ka programmi voo andmed, neid andmeid kasutatakse järgmiste tulemuste genereerimiseks. Generaator väljastab väärtusi (iteraate) erilisel viisil $-$ itereerides neid laisalt. Generaatorfunktsioon väljastab väärtusi ükshaaval salvestamata suuri andmestruktuure (nt. andmetüübid: loend, korteež, hulk, sõnaraamat, jne.) masina mällu.

Generaatorfunktsiooni defineerimiseks kasutame tavalist def blokki. Väärtuse väljastamiseks kasutame generaatorfunktsiooni blokis lausendit yield. Tuletame meelde, et tavalises Pythoni funktskoonis väljastasime tulemusi kasutades lausendit return. Lausend return lõpetab funktsiooni töö, lausend yield ei pruugi, see lõpetab generaatori töö alles siis kui ettenähtud iteratsiooniprotsess on ammendunud.

Generaator on Pythoni objekt üle mille saab itereerida.

2.1  Generaatori defineerimine

Defineerime generaatori ja itereerime üle selle kuni see ammendub. Sama generaatorit saame kasutada mitmes iteratsiooni blokis.

def int_gen():  # Defineerime generaatorfunktsiooni.
    yield 1     # Väljastame laisalt arvu 1.
    yield 2     # Väljastame laisalt arvu 2.

for i in int_gen():  # Itereerin üle generaatori. NB! Kasuta suluge.
    print(i)         # NB! Operaator in loob taustal iteraatori, vt allpool.

for i in int_gen():  # Itereerime uuesti.
    print(' ', i, end='')

1
2
  1  2

Generaatorfunktsioonile saame edastada argumente ja argumentide väärtusi. Siin kehtivad kõik meile teadaolevad def bloki reeglid ja võimalused.

def int_gen(start, stop):  # Argumentide lisamine.
    for i in range(start, stop):
        yield i

for i in int_gen(1, 3):  # Edastan argumentide väärtused.
    print(i)

1
2

Näiteks kasutame *args tüüpi argumenti:

def str_gen(*args):  # *args-tüüpi argumentide lisamine.
    for i in args:
        yield i

for i in str_gen('Juulius', 'on', 'maskott.'):
    print(i, end=' ')

Juulius on maskott. 

Mis andmetüübiga on tegu?

print(type(str_gen))
print(type(str_gen()))  # NB! Sulud.

<class 'function'>
<class 'generator'>

Väljakutse str_gen väljastab (generaator)funktsiooni ja väljakutse str_gen() väljastab generaatori.
Märkus: Generaatorfunktsiooni saab kasutada koos kõrgemat järku funktsioonidega (KJF) ning see saab ise olla KJF.

2.2  Rekursiivne generaator

Nii nagu oli tavaliste Pythoni funktsioonidega saame ka siin kasutada rekursiooni. Rekursiivse funktsiooni bloki loomiseks kasutame loodava funktsiooni nime koodibloki sees.

def infinity(start):
    yield start
    for x in infinity(start + 1):  # Viitan generaatorile endale.
        yield x

for i in infinity(0):  # Itereerime üle rekursiivse generaatori.
    if i > 5:
        break  # Peatan käsitsi.
    print(i, end=' ')

0 1 2 3 4 5 

2.3  Lõpmatu generaator

Miski ei sega meil loomast lõputut generaatorit, näiteks:

def seitse():
    while True:  # Lõpmatu tsükkel.
        yield 7

for i, j in enumerate(seitse()):
    if i > 2:
        break  # Peatan käsitsi.
    print(i * ' ', j)

 7
  7
   7

def arvud(n = 0):  # Vaikimisi alustame 0-st.
    while True:  # Lõpmatu tsükkel.
        yield n
        n += 1

for i in arvud():
    if i > 2:
        break  # Peatan käsitsi.
    print(i * ' ', i)

 0
  1
   2

2.4  Generaator ja iteraatortoega objektide konstruktorid

Pythoni sisseehitatud jadade andmetüüpide konstruktorfunktsioonid list, tuple, set ja dict itereerivad laisalt taustal üle generaatorite ja iteraatorite (vt. allpool). Peale itereerimist kasutatakse genereeritud andmeid vastava jada loomisel.

def int_gen():
    for i in [1, 2, 3]:
        yield i

list(int_gen())  # Taustal funk. list itereerib üle generaatori.

[1, 2, 3]

Märkus: Funktsioon range käitub pealtnäha väga sarnaselt generaatorile. Kuid pea meeles, et vahemik range pole tehniliselt generaator. Seega vahemik range võib teatud olukordades käituda ebaootuspäraselt. Siin aga käitub see täpselt nagu eelmise koodiraku näide:

list(range(4))  # NB! Vahemik range käitub sarnaselt eelmisele rakule.

[0, 1, 2, 3]

2.5  Generaator ja funktsioonid mis toetavad iteraatortoega objekte

Proovi ka muid sisseehitatud funktsioone mida saab rakendada iteraatortoega objektidele, nt. sum. Paljud Pythoni funktsioonid mida saab rakendada iteraatotorga objektidele toetavad generaatoreid. Generaator on iteraatortoega objekt.

def int_gen():
    for i in [1, 2, 3]:
        yield i

sum(int_gen())  # Taustal itereerib üle generaatori.

6

2.6  Generaator ja lahtipakkimise operaator *

Lahtipakkimise operaator * toetab iteraatortoega objekte seega ka generaatorit. Operaator itereerib üle iteraatide leides väärtused mida tagastada. Operaator * ammendab generaatori.

def gen():
    yield 1
    yield 2

print(*gen())  # Itereerib, pakib lahti. Generaatori objekt on ammendatud.
print([*gen()])  # Pakin lahti listi.

1 2
[1, 2]

Märkus: Sõnastike lahtipakkimise operaator ** ei saa generaatorit lahti pakkida kuna väljakutse gen() tagastab generaatori mitte sõnastiku.
Loomulikult saame laisalt väljastada sõnastikke ja tulemused ise kokku ühendada sõnastikuks mida siis omakorda lahti pakkida.

def gen():
    yield {'key1': 1}  # Väljastab sõnastikke.
    yield {'key2': 2}

kokku = {k: v for d in gen() for k, v in d.items()}  # Sõnastiku avaldis.
print(type(kokku)) 
print({**kokku})  # Pakin lahti sõnastikku.
print(kokku)

<class 'dict'>
{'key1': 1, 'key2': 2}
{'key1': 1, 'key2': 2}

kokku = {}
for d in gen():
    kokku |= d  # Dictionary union. Sõnastike ühend.

print(type(kokku))
print({**kokku})  # Pakin lahti sõnastikku.
print(kokku)

<class 'dict'>
{'key1': 1, 'key2': 2}
{'key1': 1, 'key2': 2}

2.7  Funktsiooni print iteratiivne väljakutse ning lausendite yield ja return võrdlus

Keegi ei keela kirjutada funktsiooni või generaatorfunktsiooni mis väljastab iteratiivselt funktsiooni print väljakutseid. Kirjutame generaatori:

def gen():
    for i in range(5):
        yield print(i, end=' ')
        
for tegevus in gen():
    tegevus

0 1 2 3 4 

Kood töötab ootuspäraselt. Analoogne funktsiooniblokk kus lausend yield on asendatud lausendiga return on kujul:

def fun():
    for i in range(5):
        return print(i, end=' ')  # Lausendiga return me nii ei saanud teha aga siin on see lubatud.
        
fun()

0 

See kood ei ole võimeline kõiki iteraatsioonitsükleid teostama kuna lausend return väljub def blokist peale esimest tsüklit.

3  Iteraator ehk generaatori objekt

Generaatori abil saame luua iteraatori ehk generaatori objekti. Generaatori abil loodud iteraatorit nimetatakse vahest ka laisaks iteraatoriks, kuna itereerimine on laisk. Iteraator on iteraatortoega. Eelnevalt olema kasutanud for ja while tsükleid, et itereerida üle iteraatortoega objektide. Lisaks saame itereerida ka üle iteraatorite.

Objekti loomiseks kasutame meelevaldset muutjanime, generaatorit ja omistusoperaaatorit =. Süntaks on järgmine:

<iteraatori nimi> = <generaatori nimi>(<argumendid kui on>)

Kui sulle tundub veider, et see rida loob iteraatori siis mõtle järgmistele näidetele:

n = int(3)

lst = list([1, 2, 3])

print(type(n))
print(type(lst))

<class 'int'>
<class 'list'>

Teatavasti on andmetüübid defineeritud klassides, täisarvud klassis int ja loendid klassis list. Siin lõime klassi (konstruktorfunktsiooni) abil objekte. Klass on koht mis kirjeldab objekti, seega on see võimeline objekti looma. Sarnaselt klassile on generaator koht kus kirjeldatakse või defineeritakse generaatori objekt ja seetõttu saame selle abil luua generaatori objekti ehk iteraatori.

Ühe generaatori abil saame luua meelevaldse arvu iteraatoreid. Iga uus iteraator on alglähtestatud.

Generaator ja selle abil loodu iteraator on objektid üle mille saab itereerida.

3.1  Iteraatori defineerimine

Defineerime generaatori, loome selle abil iteraatori ehk generaatori objekti ja itereerime üle selle.
Märkus: Ära kasuta iteraatori nimena nime iter mis on sissehitatud objektide nimeruumi nimi.

def int_gen(): 
    yield 1 
    yield 2

iteraator = int_gen()  # NB! Loome iteraatori nimega 'iteraator'.
for i in iteraator:    # Itereerin üle iteraatori.
    print(i)

iteraator2 = int_gen()  # Uue iteraatori loomine kasutades sama generaatorit.
for i in iteraator2:    # Itereerin üle teise iteraatori.
    print(' ', i, end='')

1
2
  1  2

Generaatorfunktsioonile saame endiselt edastada argumente. Siin kehtivad kõik meile teadaolevad def bloki reeglid ja võimalused.

def int_gen(start, stop):  # Argumentide edastamine.
    for i in range(start, stop):
        yield i

iter1 = int_gen(5, 8)  # Loome iteraatori.

for i in iter1:  # Itereerime üle iteraatori.
    print(i, end=' ')

5 6 7 

Kasutame *args tüüpi argumenti:

def str_gen(*args):  # *args-tüüpi argumentide lisamine.
    for i in args:
        yield i

iter1 = str_gen('Python', 'on', 'madu.')  # Lisa meelevaldne arv väärtusi.

for i in iter1:  # Itereerime üle iteraatori.
    print(i, end=' ')

Python on madu. 

Kontrollime mis objektiga on tegemist:

obj = str_gen(1, 2, 3)  # Loome generaatori objekti ehk iteraatori.
print(obj)  # Generaatori objekt on iteraator.

<generator object str_gen at 0x110722140>

3.2  Objektide loomisest laiemalt

3.2.1  Iteraatori loomine, lisainfo

Mida teeb omistuoperaator = täpsemalt kui me kasutame seda iteraatori loomisel? Kas toimub objektidele viitamine? Kas toimub andmetele viitamine? Uurime järgmisi näiteid:

import types

def object_id(obj1, obj2):
    """Võrdleb objektide id-sid ja nende andmeid."""
    print('Sama objekt:', obj1 is obj2)  # Erinevad objektid, erinevad funktsiooni id väärtused.
    if isinstance(obj1, types.GeneratorType):
        print('Samad andmed:', list(obj1) == list(obj2))  # Samad andmed.
    else:
        print('Samad andmed:', obj1 == obj2)  # Samad andmed.
    print('id(obj1) =', id(obj1))
    print('id(obj2) =', id(obj2))
    print('id(obj2) - id(obj1) =', id(obj2) - id(obj1))
    
def gen():
    yield 1 
    yield 2

obj1 = gen()  # Loome objekti.
obj2 = obj1  # Viitame objektile.

object_id(obj1, obj2)  # Sama objekt.

Sama objekt: True
Samad andmed: False
id(obj1) = 4570862992
id(obj2) = 4570862992
id(obj2) - id(obj1) = 0

Uue iteraatori loomine loob uue objekti koos uute andmetega. Sisuliselt lõime koopia:

obj1 = gen()
obj2 = gen()

object_id(obj1, obj2)  # Uus objekt. obj2 on obj1 koopia.

Sama objekt: False
Samad andmed: True
id(obj1) = 4570864048
id(obj2) = 4570863696
id(obj2) - id(obj1) = -352

3.2.2  Objekti loomine kui koopia tegemine

Sama kopeerimise idee kehtib ka konstruktorfunktsioonide kasutamisel järgmisel viisil:

obj1 = 333
obj2 = obj1  # Viitame objektile.

object_id(obj1, obj2)  # Sama objekt.

Sama objekt: True
Samad andmed: True
id(obj1) = 4572817584
id(obj2) = 4572817584
id(obj2) - id(obj1) = 0

Konstruktorfunktsioonid int jne. loovad uue koopia:

obj1 = 333
obj2 = int(333)  # Loon uue objekti. Ei kehti väikeste arvude puhul.

object_id(obj1, obj2)  # Tegi uue objekti (koopia).

Sama objekt: False
Samad andmed: True
id(obj1) = 4572815888
id(obj2) = 4572819280
id(obj2) - id(obj1) = 3392

Sarnane näide kasutades loendi andmetüüpi:

obj1 = [1, 2, 3]
obj2 = obj1  # Viitame objektile.

object_id(obj1, obj2)  # Sama objekt.

Sama objekt: True
Samad andmed: True
id(obj1) = 4573038464
id(obj2) = 4573038464
id(obj2) - id(obj1) = 0

Kasutame konstruktorfunktsiooni list ja loome koopia:

obj1 = [1, 2, 3]
obj2 = list(obj1)  # Loon uue objekti.

object_id(obj1, obj2)  # Tegi koopia.

Sama objekt: False
Samad andmed: True
id(obj1) = 4573252224
id(obj2) = 4573010240
id(obj2) - id(obj1) = -241984

3.2.3  Jadade lõikumine kui koopia tegemine

Lisaks eelmainitule tasub teada, et Pythonis kehtivad ka järgmised indekseerimise ja lõikudeks jagamise reeglid.

obj1 = [1, 2, 3]
obj2 = obj1[:]  # Loob uue objekti. Terve list.

object_id(obj1, obj2)  # Tegi koopia.

Sama objekt: False
Samad andmed: True
id(obj1) = 4573250432
id(obj2) = 4573328128
id(obj2) - id(obj1) = 77696

obj1 = [1, 2, 3]
obj2 = obj1[1:]  # Loob uue objekti. Lõik listist.

object_id(obj1, obj2)  # Teine objekt loodi.

Sama objekt: False
Samad andmed: False
id(obj1) = 4573252224
id(obj2) = 4573870016
id(obj2) - id(obj1) = 617792

Vahemikku range saab indekseerida, seega:

a = range(4)
b = a[:]  # Loob uue objekti.

object_id(a, b)  # Tegi koopia.

Sama objekt: False
Samad andmed: True
id(obj1) = 4573099664
id(obj2) = 4573238624
id(obj2) - id(obj1) = 138960

a = range(4)
b = a[1:]  # Loob uue objekti.

object_id(a, b)  # Teine objekt loodi.

Sama objekt: False
Samad andmed: False
id(obj1) = 4573242512
id(obj2) = 4573099664
id(obj2) - id(obj1) = -142848

3.3  Iteraator ja sisseehitatud funktsioon next

Iteraatori järgmise väärtuse saab laisalt väljastada kasutades sisseehitatud funktsiooni next:

def int_gen():
    for i in [1, 2, 3, 4, 5]:
        yield i

g = int_gen()  # Loome iteraatori g.
next(g)  # Rakenda funktsiooni next iteraatorile.

1

next(g)  # Mäletab itraatori olekut.

2

next(g)  # Järgmine iteraat, jne.

3

Märkus: Funktsiooni next pole mõtet korduvalt ja otse rakendada generaatorile. Antud juhul esimene funktsioon next väljastab esimese iteraadi, teine väljakutse loob uue alglähtestatud generaatori ja tagastab jälle esimene tulemus (lisaks vt. selle dokumendi lõppu).

print(next(int_gen()))
print(next(int_gen()))  # NB! Esimene iteraat.

g2 = int_gen()  # Loon uue iteraatori g2.

i = 1
while i < 4:
    print(next(g2), end=' ')
    i += 1

1
1
1 2 3 

3.4  Iteraatori ammendumine ja erisus StopIteration

Kui iteraator on ammendunud siis tõstatakse erisus StopIteration. Pythoni erisusestest ja veateadetest räägime tuleviku loengutes üksikasjalikumalt.

def int_gen():
    for i in [1, 2]:
        yield i

g = int_gen()

next(g)

1

next(g)

2

next(g)  # Järgmist väärtust pole olemas, iteraator ammendus.

---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
Cell In[37], line 1
----> 1 next(g)

StopIteration: 

3.5  Lõpmatu iteraator

Eespool nägime lõpmatute generaatorite näiteid. Taasesitame need siin ja loome nende põhjal ka iteraatorid:

def seitse():
    while True:  # Lõpmatu tsükkel.
        yield 7

s = seitse()  # Loon lõpmatu iteraatori.

i = 0
while i < 3:  # Peatan itereerimise käsitsi.
    print(i * ' ', next(s))  # Väärtuse loomine ja väljastamine.
    i += 1

 7
  7
   7

def arvud(n = 0):  # Vaikimisi alustame 0-st.
    while True:  # Lõpmatu tsükkel.
        yield n
        n += 1

num = arvud()  # Loome iteraatori num.

a = [next(num) for _ in range(5)]  # Loendi avaldis ja funktsioon next.
b = [next(num) for _ in range(5)]  # Sama iteraator, mäletab viimast iteraatori olekut.
print(a, '-->', b)

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

3.6  Iteraator ja iteraatortoega objektide konstruktorid

Eespool juba mainisime, et Pythoni sisseehitatud andmetüüpide kostruktorfunktsioonid list, tuple, set ja dict itereerivad taustal üle generaatorite ja iteraatorite. Kuna iteraator on iteraatortoega.

def int_gen():
    for i in [1, 2, 3]:
        yield i

g = int_gen()

print(list(g))  # Taustal funk. list itereerib üle iteraatori.

[1, 2, 3]

3.7  Itreaator ja funktsioonid mis toetavad iteraatortoega objekte

Paljud sisseehitatud funktsioonid toetavad iteraatortoega objektidele, nt. sum:

def int_gen():
    for i in [1, 2, 3]:
        yield i

g = int_gen()

print(sum(g))  # Taustal itereerib üle iteraatori.

6

3.8  Rekursiivne itereerimine

Eespool defineeritud rekursiivsed generaatorid loovad rekursiivseid iteraatoreid.

def infinity(start):
    yield start
    for x in infinity(start + 1):  # Viitan generaatorile endale.
        yield x

inf = infinity(0)

i = 0
while i < 3:  # Peatan itereerimise käsitsi.
    print(next(inf), end=' ')
    i += 1

0 1 2 

3.9  Sisseehitatud funktsioon iter

Funktsioon iter loob iteraatori kasutades iteraatortoega objekte ehk teisendab iteraatortoega objekte iteraatoriks. Iteraatori konstruktorfunktsioon. Näide kasutades iteraatortoega loendit:

lst = [1, 2, 3]  # Proovi ka teisi andmetüüpe.

iter_lst = iter(lst)  # Funktsiooni iter rakendamine loendile.

print(type(iter_lst))
print(next(iter_lst),
      next(iter_lst))  # Väljastan kaks esimest iteraati.

<class 'list_iterator'>
1 2

for i in iter_lst:
    print(i)  # Mäletab eelmist olekut.

3

Näide kus kasutame iteraatortoega sõnet:

st = 'Python'

iter_st = iter(st)

print(type(iter_st))
print(next(iter_st),
      next(iter_st))  # Väljastan kaks esimest iteraati.

<class 'str_ascii_iterator'>
P y

for i in iter_st:
    print(i, end=' ')  # Mäletab eelmist olekut.

t h o n 

3.10  Iteraator ja lahtipakkimise operaator *

Lahtipakkimise operaator * toetab iteraatortoega objekte seega ka iteraatorit. Operaator itereerib üle iteraatide leides väärtused mida tagastada. Operaator * ammendab iteraatori.

def gen():
    yield 1
    yield 2

obj = gen()
print(*obj)  # Itereerib, pakib lahti. Iteraator on ammendatud.

obj2 = gen()
print([*obj2])  # Pakin lahti listi.

1 2
[1, 2]

Märkus: Sõnastike lahtipakkimise operaator ** ei saa iteraatorit lahti pakkida kuna väljakutse obj tagastab generaatori objekti mitte sõnastiku.
Loomulikult saame laisalt väljastada sõnastikke ja tulemused ise kokku ühendada sõnastikuks mida siis omakorda lahti pakkida.

def gen():
    yield {'key1': 1}  # Väljastab sõnastikke.
    yield {'key2': 2}

obj = gen()

sr = {**next(obj), **next(obj)}  # Panen käsitsi kokku.
print(type(sr))
print({**sr})  # Pakin lahti sõnastikku.
print(sr)

<class 'dict'>
{'key1': 1, 'key2': 2}
{'key1': 1, 'key2': 2}

obj = gen()

kokku = {k: v for d in obj for k, v in d.items()}  # Sõnastiku avaldis.
print(type(kokku))
print({**kokku})  # Pakin lahti sõnastikku.
print(kokku)

<class 'dict'>
{'key1': 1, 'key2': 2}
{'key1': 1, 'key2': 2}

obj = gen()

kokku = {}
for d in obj:
    kokku |= d  # Dictionary union. Sõnastike ühend.

print(type(kokku))
print({**kokku})  # Pakin lahti sõnastikku.
print(kokku)

<class 'dict'>
{'key1': 1, 'key2': 2}
{'key1': 1, 'key2': 2}

4  Lausend yield from

4.1  Alamgeneraator

Alltoodud näidet kasutame all pool lausendi yield from seletamiseks. Uurime näidet:

def generator1():
    for i in range(3):
        yield 'Gen 1:', i

def generator2():
    for i in range(3, 6):
        yield '\tGen 2:', i


def generator():
    for i in generator1():  # Itereerin üle generaatori, LEGB reegel.
        yield i
    for i in generator2():  # Itereerin üle generaatori, LEGB reegel.
        yield i


for i in generator():
    print(i[0], i[1])

Gen 1: 0
Gen 1: 1
Gen 1: 2
	Gen 2: 3
	Gen 2: 4
	Gen 2: 5

Lausend yield from võimaldab alamgeneraatori kasutust generaatori bloki sees. Lausend võimaldab eelmist näidet tunduvalt lühendada:

def generator():
    yield from generator1()
    yield from generator2()

for i in generator():
    print(i[0], i[1])

Gen 1: 0
Gen 1: 1
Gen 1: 2
	Gen 2: 3
	Gen 2: 4
	Gen 2: 5

Lausend yield from toetab ka iteraatorit:

obj1 = generator1()
obj2 = generator2()

def generator():
    yield from obj1
    yield from obj2

for i in generator():
    print(i[0], i[1])

Gen 1: 0
Gen 1: 1
Gen 1: 2
	Gen 2: 3
	Gen 2: 4
	Gen 2: 5

4.2  Rekursioon ja lausend yield from

Lausendit yield from kasutatakse rekursiivsetes generaatorites. Rekursioon ja lausend yield from:

def infty(start):
    yield start
    yield from infty(start + 1)  # Rekursiooni loomine.

for i in infty(0):  # Itereerime üle generaatori.
    if i < 3:  # Peatame itereerimise käsitsi.
        print(i)
    else:
        break

0
1
2

def recursive_generator(lst):  # Argumendina eeldame listi.
    if lst:  # Triviaalse objekti booli tõeväärtus on False.
        yield lst[0]
        yield from recursive_generator(lst[1:])  # Rekursiooni loomine.

for k in recursive_generator([6, 2, 5]):
    print(k)

6
2
5

5  Kõrgemat järku generaatorfunktsioon

Generaatori defineerimisel saame argumendina edastada funktsioone või väljastada ehk yield-da funktsioone. Seega saame defineerida kõrgemat järku generaatorfunktsioone (KJGF). Täpselt nii nagu saime seda teha tavaliste Pythoni KJF defineerimisel.

5.1  Näide: Logistilise kujutuse itereerimine

Logistiline kujutus on antud kujul:

$$ x_{n+1} = r x_n (1 − x_n), $$

kus $r$ on kontrollparameeter omades väärtusi vahemikus $[0, 4]$, $n \in \mathbb{Z}$ on itereerimisindeks ja iteraat $x_n$ saab omada väärtusi vahemikus $[0, 1]$.

Kasutame ülaltoodud kujutuse funktsiooni kujul:

$$ f(x) = r x (1 − x), $$

generaatorfunktsiooni argumendi väärtusena ning leiame kujutuse või kujutise iteraadid $x_{n+1} = f(x_n)$ ehk logistilise kujutise.

Viide: https://en.wikipedia.org/wiki/Logistic_map

def iterate_func(func, x):  # KJGF.
    while True:  # Lõpmatu tsükkel.
        yield x
        x = func(x)  # Rakendame funktsiooni func x-le ja kirjutame x väärtuse üle.

r = 3.7
f = lambda x: r*x*(1 - x)
iterates_xn = iterate_func(f, 0.6)  # Loome iteraatori.

for _ in range(5):  # Peatan itereerimise käsitsi.
    print(next(iterates_xn))

0.6
0.8880000000000001
0.3679871999999997
0.8605186963537916
0.44409719744364157

Sama näide, siin salvestame leitud väärtused loendisse:

x = iterate_func(f, 0.6)  # Uus iteraator.

lst = []
for _ in range(5):  # Peatan itereerimise käsitsi.
    lst.append(next(x))  # Lisan iteraadid algselt tühja listi.
    
print(lst)

[0.6, 0.8880000000000001, 0.3679871999999997, 0.8605186963537916, 0.44409719744364157]

6  Generaatoravaldis ehk generaatori lühiesitus (generator comprehension)

Eelmisel nädalal tutvustatud for-in avaldis (list comprehension, set comprehension, dictionary comprehension) lõi listi, hulga või sõnaraamatu mis omakorda hoiab kõiki loodud elemente masina mälus. Nagu juba eespool mainitud, generaator ja ka selle allpool tutvustatud lühiesitus ei loo suurt mälustruktuuri vaid väljastab tulemused laisalt ehk ühekaupa ja vastavalt vajadusele.

6.1  Generaatoravaldise defineerimine

Generaatoravaldist defineerime kasutades süntaksis ümaraid sulge. See on ka põhjus miks eelmine nädal ei defineeritud korteežiavaldist (tuple comprehension). Korteežiavaldist pole olemas kuna see defineerib generaatori.

6.1.1  Kasutades for-in avaldist

Nii nagu eelmise nädala loengus kus filtreerisime liste, hulkasid ja sõnaraamatuid, saame ka generaatoravaldistes kasutada for-in avaldist. Näiteks loome generaaatori mis genereerib laisalt ruute:

(i**2 for i in range(4)) 

<generator object <genexpr> at 0x110734860>

print(type(i**2 for i in range(4)))

ruudud = (i**2 for i in range(4))
print(type(ruudud))
print(ruudud)  # Generaatori objekt ehk iteraator.

<class 'generator'>
<class 'generator'>
<generator object <genexpr> at 0x11013bc60>

list(ruudud)  # Transleerime iteraadid listi.

[0, 1, 4, 9]

rd = (i**2 for i in range(3))  # Anname nime generaatorile.

for i in rd:  # NB! Itereerin üle generaatori.
    print(i)

0
1
4

6.1.2  Kasutades for-in-if avaldist

Nii nagu eelmise nädala loengus kus filtreerisime liste, hulkasid ja sõnaraamatuid, saame ka generaatoravaldistes kasutada for-in-if avaldist. Näiteks loome generaaatori mis genereerib laisalt ainult paarituid ruute:

ptud_ruudud = (i**2 for i in range(7) if i % 2)  # Võrdväärne tingimusega i % 2 == 1.

for i in ptud_ruudud:
    print(i)

1
9
25

6.1.3  Kasutades pesastatud for-in avaldisi

Pesastatud for-in avaldise kasutamine generaatoravaldises, vt. vrd. eelmise nädala materjale:

nested_gen = ((n, m) for n in range(2) for m in range(10, 12))

for j in nested_gen:
    print(j)

(0, 10)
(0, 11)
(1, 10)
(1, 11)

6.1.4  Kasutades if-else valikuavaldist koos for-in avaldisega

Näide: Filtreeri laisalt loend a generaatoravaldise abil: Juhul kui arv on suurem või võrdne $50$-ga liida sellele $1$, juhul kui arv on väiksem kui $50$ liida sellele $5$.

a = [22, 13, 45, 50, 98, 69, 43]
arvud = (x + 1 if x >= 50 else x + 5 for x in a)

for i in arvud:
    print(i, end=' ')

27 18 50 51 99 70 48 

6.1.5  Kasutades if-else valikuavaldist koos for-in-if avaldisega

Näide: Filtreeri laisalt loend a generaatoravaldise abil:

1. Elimineeri paaritud arvud.
2. Juhul kui paaris arv on suurem või võrdne $50$-ga liida sellele $1$, juhul kui paaris arv on väiksem kui $50$ liida sellele $5$.

a = [22, 13, 45, 50, 98, 69, 43, 44, 1]
numbrid = (x + 1 if x >= 50 else x + 5 for x in a if x % 2 == 0)

for i in numbrid:
    print(i, end=' ')

27 51 99 49 

6.2  Generaatoravaldise ja funktsioonid mis toetavad iteraatortoega objekte

Nii nagu eespool nägime saame generaatorit ja ka selle poolt loodud iteraatorit kasutada sisseehitatud iteraatortoega funktsioonide argumentidena. Ka generaatoravaldist saab kasutada funktsiooni argumendina $-$ sellisel juhul pole isegi vaja kasutada kahte paari sulge.

Näide: Leiame esimese miljoni mitte-negatiivse täisarvu ruutude summa kasutades sisseehitatud funktsiooni sum.

sum(i**2 for i in range(1_000_000))  # Funktsiooni sum sulud defineerivad generaatori.

333332833333500000

6.3  Lausendid yield ja yield from ning avaldiste lühiesitused

Lausendit yield ei saa kasutada listi-, hulga-, sõnastiku- ja generaatoravaldistes. Süntaks kujul:

[yield i for i in range(5)]

  Cell In[67], line 1
    [yield i for i in range(5)]
     ^
SyntaxError: invalid syntax

on vigane. Lausend yield võib esineda ainult generaatorfunktsiooni blokis — see tähendab def blokis. Sama kehtib ka lausendi yield from kohta:

[yield from (i for i in range(3))]

  Cell In[68], line 1
    [yield from (i for i in range(3))]
     ^
SyntaxError: invalid syntax

Lausendeid yield ja yield from saab kasutada generaatoravaldise ees ja ainult def bloki sees:

def gen_outer():
    yield (x for x in range(5))

print(list(*gen_outer()))

[0, 1, 2, 3, 4]

def gen_outer():
    yield from (x for x in range(5))

print(list(gen_outer()))

[0, 1, 2, 3, 4]

7  Liitgeneraator (pipelining generators, pipelining data)

Liitgeneraatori all mõistame mitme generaatorite järjestikku rakendamist iteraatortoega andmetele. Protsess sarnaneb matemaatikatunnist teada liitfunktsioonile kus seda funktsiooni rakendatakse laisalt jadalaadsetele andmetele.

Liitgeneraatori rakendamisel saame rääkida nn. andmevoost (data pipeline). Andmevoog on järjestikuste töötlemisetappide ahel, mille käigus andmed läbivad mitmeid samme ja muunduvad end algolekust lõppolekusse. Lihtsamalt öeldes on see toimingute jada, mis muudab andmeid. Andmeid muudetakse tavaliselt ühe kaupa.

Liitgeneraatori andmevoog koosneb tavaliselt järgmistest sammudest:

1. Andmete sisselugemine (data Ingestion) või loomine: andmete lugemine erinevatest allikatest, näiteks API-dest, andmebaasidest või failidest.
2. Andmete muutmine (data Transformation) toimingute jadas: andmete puhastamine, filtreerimine, muutmine ja teisendamine.
3. Andmete laadimine (data Loading): muudetud andmete salvestamine või kasutamine.

7.1  Liitfunktsioon, meeldetuletus

Liitfunktsiooni saame andmevoo kontekstis defineerida järgmiselt:

$$ f(x) \doteq \underbrace{f_{n} \Big( f_{n-1} \big(\ldots f_3 \big( f_2 (f_1 }_{n} ( \{ \overbrace{x_1, x_2, \ldots, x_{m-1}, x_m }^{m} \} \underbrace{) ) \big) \ldots \big) \Big)}_{n} $$

kus $n$ on kasutatud funktsioonide $f_i$ arv, kusjuures $i \in [1, 2, \ldots, n-1, n]$, ja kus $x = \{ x_1, x_2, \ldots, x_{m-1}, x_m \}$ on jada tüüpi Pythoni objekt, nt. hulk, kus $m$ on täisarv. Funktsiooni $f(x)$ nimetatakse liitfunktsiooniks. Andmevoo stsenaariumis rakendatakse funktsioone $f_i$ kõigile jada elementidele $x_j$ kus $j \in [1, 2, \dots, m-1, m]$ ühe kaupa.

Liitfunktsiooni näide, reaalarvuline funktsioon on kujul:

$$ f(x) = \sqrt{\exp(x^2)}. $$

Funktsooni saab jagada kolemeks osaks:

$$ f_1(x) = x^2, $$

$$ f_2(x) = \exp(x), $$

$$ f_3(x) = \sqrt{x}. $$

7.2  Liitfunktsioon ja mitte-laisk iteratsioon

Võrdluseks vaatama lihtsat näidet:

def fun1(x):
    return x * 2

def fun2(x):
    return x + 1

def liitfun(x):
    return fun2(fun1(x))  # Liitfunktsioon.

for i in [1, 2, 3]:  # Rakendame listi igale elemendile.
    print(liitfun(i))

3
5
7

See näide demonstreerib andmete voogu:

def fun1(x):
    l = []
    for i in x:
        l.append(i * 2)
    return l

def fun2(x):
    l = []
    for i in x:
        l.append(i + 1)
    return l

def liitfun(sisend):  # Andmed sisenevad ja voolavad läbi.
    tulem_1 = fun1(sisend)
    tulem_2 = fun2(tulem_1)
    return tulem_2


print(liitfun([1, 2, 3]))

[3, 5, 7]

Sama tulemuse saame kasutades lühemat kirjapilti:

def fun1(x):
    return [i * 2 for i in x]

def fun2(x):
    return [i + 1 for i in x]

def liitfun2(x):
    return fun2(fun1(x))

print(liitfun2([1, 2, 3]))

[3, 5, 7]

7.3  Liitgeneraator ja laisk iteratsioon

Siin kasutame generaatoreid ja spetsiaalset liitgeneraatori defineerimise süntaksit.
NB! Pane tähele, et andmevoog toimub nagu eespool kirjeldatud. Kaks funktsiooni muudavad andmeid ühe kaupa ja ammendavad kogu etteantud jada.

def gen1(x):  # NB! Eeldame, et x on jada.
    for i in x:
        yield i * 2

def gen2(x):  # NB! Eeldame, et x on jada.
    for i in x:
        yield i + 1


liit_iteraator = gen2(gen1([1, 2, 3]))  # Liitgeneraator. Generator pipelining.

for i in liit_iteraator:
    print(i)

3
5
7

Demonstreerime mis järjekorras teostatakse tulemuste laisk leidmine. Kasutame funktsiooni print:

def gen1(x):  # NB! Eeldame, et x on jada.
    for i in x:
        print('Sisenes gen1')
        yield i * 2

def gen2(x):  # NB! Eeldame, et x on jada.
    for i in x:
        print('Sisenes gen2')
        yield i + 1


liit_iteraator = gen2(gen1([1, 2, 3]))  # Liitgeneraator. Generator pipelining.

for i in liit_iteraator:
    print('  ', i)

Sisenes gen1
Sisenes gen2
   3
Sisenes gen1
Sisenes gen2
   5
Sisenes gen1
Sisenes gen2
   7

NB! Väljakutse gen2(gen1([1, 2, 3])) teostatakse taustal erilisel viisil rakendades jadamisi generaatoreid gen1 ja siis gen2 listi elementidele ühekaupa.

Eelmise kahe koodiraku koodi saab loomulikult ka teisiti kirjutada, lühem kirjapilt:

sisend = [1, 2, 3]

gen1 = (i * 2 for i in sisend)
gen2 = (i + 1 for i in gen1)

for i in gen2:
    print(i)

3
5
7

Kasutades avaldiste pesastamist:

sisend = [1, 2, 3]

gen = (i + 1 for i in (i * 2 for i in sisend))

for i in gen:
    print(i)

3
5
7

Kasutades liitfunktsiooni generaatoriavaldise sees.

fun1 = lambda x: x * 2
fun2 = lambda x: x + 1
liitfun = lambda x: fun2(fun1(x))  # Liitfunktsioon.

sisend = [1, 2, 3]
gen = (liitfun(i) for i in sisend)

for i in gen:
    print(i)

3
5
7

7.4  Näide: Moondatud Fibonacci jada

Leiame Fibonacci jada liikmete ruutude ruutjuured (nonsenss) kasutades generaatorite järjest rakendamist. Vastuseks peab tulema jada ise. Fibonacci jada on kujul:

$$ 1 \quad 1 \quad 2 \quad 3 \quad 5 \quad 8 \quad 13 \quad 21 \quad 34 \quad 55 ~~ \ldots $$

Allolevas koodis genereeritakse (iteratiivselt, mitte-rekursiivselt) esimene Fibonacci jaga liige, siis rakendatakse sellele ruutu tõstmine ja lõpuks seda juuritakse. Peale esimese tulemuse väljastuse teostatakse sama protsess teise Fibonacci jada liikmega, jne.:

def fibonacci(n):
    x, y = 0, 1
    for _ in range(n):  # Leitakse ainult n jada liiget.
        x, y = y, x + y
        yield x

def ruudud(xid):  # NB! Eeldab iteraatortoega sisendit.
    for i in xid:
        yield i ** 2
        
def juured(xid):  # Eeldab iteraatortoega sisendit.
    for i in xid:
        yield int(i ** 0.5)

koos = juured(ruudud(fibonacci(10)))  # Liititeraatori loomine.

for i in koos:  # Laisk itereerimine üle iteraatori.
    print(i, end=' ')

1 1 2 3 5 8 13 21 34 55 

Generaatoreid saab järjest rakendada ka funktsioonide argumendi sulgudes. Näiteks Fibonacci jada kümne esimese liikme ruutude ja siis juurte summa on leitav nii:

sum(juured(ruudud(fibonacci(10))))

143

Sarnane kood kasutades lühemat kirjapilti tänu generaatoriavaldisele:

# Meetod append tagastab triviaalse objekti (tühimärk None),
# seega operaator or tagastab state.pop(0) mis ka tagastab triviaalse objekti.
n = 10

olek = [1, 1]
fib = (olek.append(olek[0] + olek[1]) or olek.pop(0) for _ in range(n))
ruudud = (i ** 2 for i in fib)
juured = (int(i ** 0.5) for i in ruudud)

for i in juured:
    print(i, end=' ')

1 1 2 3 5 8 13 21 34 55 

Pesastamine lubab ridu veelgi kokku hoida, koodi loetavuse arvelt:

n = 10
x = [1, 1]
juured = (int(i**0.5) for i in (i**2 for i in (x.append(x[0] + x[1]) or x.pop(0) for _ in range(n))))

for i in juured:
    print(i, end=' ')

1 1 2 3 5 8 13 21 34 55 

8  Mis vahe on iteraatoril ja iteraatortoega objektil?

Erinevused mis puudutavad funktsiooni iter:

• Iteraatortoega objektile saame mõtestatult rakendada funktsiooni iter ehk teisendada seda iteraatoriks.
• Generaatorile pole tavaliselt mõtet rakendada funktsiooni iter, tagastab iteraatori. Kasuta parem obj = gen().
• Iteraatorile pole mõtet rakendada funktsiooni iter, tagastab iseenda.

Erinevused mis puudutavad funktsiooni next:

• Iteraatortoega objektile ei saa rakendada funktsiooni next, tõstatub erisus TypeError.
• Iteraatorile saab rakendada funktsiooni next.
• Generaatoritele pole tavaliselt mõtet rakendada funktsiooni next, väljastab alati esimese iteraadi.

Erinevused mis puudutavad itereeritavust (puuduvad):

• Iteraatortoega objekti saab itereerida for- ja while-tsüklis.
• Generaatorit saab itereerida for- ja while-tsüklis.
• Iteraatorit saab itereerida for- ja while-tsüklis.

Allolevates näidetes vastavad maagilistele meetoditele või nn. dunder-meetoditele __iter__ ja __next__ meile tuttavad sisseehitatud funktsioonid iter ja next.

a = [1, 2, 3, 4]  # Iteraatortoega list.
print(type(a))
dir(a)  # Puudub meetod __next__ aga on meetod __iter__.

<class 'list'>

['__add__',
 '__class__',
 '__class_getitem__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__getstate__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__rmul__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'append',
 'clear',
 'copy',
 'count',
 'extend',
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']

def gen():  # Iteraatortoega generaator.
    yield 1

print(type(gen()))
dir(gen())  # Eksisteerivad meetodid __next__ ja __iter__.

<class 'generator'>

['__class__',
 '__del__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getstate__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__lt__',
 '__name__',
 '__ne__',
 '__new__',
 '__next__',
 '__qualname__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'close',
 'gi_code',
 'gi_frame',
 'gi_running',
 'gi_suspended',
 'gi_yieldfrom',
 'send',
 'throw']

iteraator = iter(a)  # Iteraator.

print(type(iteraator))
dir(iteraator)  # Eksisteerivad meetodid __next__ ja __iter__.

<class 'list_iterator'>

['__class__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getstate__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__length_hint__',
 '__lt__',
 '__ne__',
 '__new__',
 '__next__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__setstate__',
 '__sizeof__',
 '__str__',
 '__subclasshook__']

Kuna funktsioonile iter vastab dunder-meetod __iter__ saame funktsiooni iter väljakutse asendada meetodi rakendamisega:

a = [1, 2, 3, 4]  # Iteraatortoega list.
iteraator2 = a.__iter__()  # Ekvivalentne tulemus eelmises rakus näidatuga.

print(type(iteraator2))

<class 'list_iterator'>

Iteraatorile saame rakendada sisseehitatud funktsiooni next ja sellele vastavat dunder-meetodit __next__. Iteraatortoega objektile seevastu ei saa:

print(next(iteraator2))  # Esimene iteraat.
print(iteraator2.__next__())  # Teine iteraat.

for i in iteraator2:  # Laisk itereerimine, ülejäänud iteraadid.
    print(' ', i)

1
2
  3
  4

next(a)  # Kasutan eespool loodud listi a.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[88], line 1
----> 1 next(a)

TypeError: 'list' object is not an iterator

☻   ☻   ☻