0 dní v řadě · 0 bodů

Python pod kapotou · 22 min

Iterátorový protokol

Zjistíš, co cyklus for dělá doopravdy, proč jdou některá data projít jen jednou a jak napsat vlastní objekt, který se dá procházet.

Hloubka
Úkoly
Lidsky řečeno

Vezmi si knihu a záložku. Kniha obsahuje všechny stránky, ale netuší, kde zrovna jsi. To ví záložka. Umí jediné: ukázat další stránku a posunout se o kus dál. Do jedné knihy si může dát záložku víc lidí a každý čte svým tempem. Když záložka dojde na konec, skončila. Chceš číst znovu? Vezmeš si novou. V Pythonu se kniha jmenuje iterable a záložka iterátor.

Co dělá for, když se nikdo nedívá

Cyklus for nemá ponětí, co je seznam, slovník nebo soubor. Umí jen dvě věci a stačí mu to na všechno:

  • iter(x) požádá objekt o iterátor, tedy o tu záložku.
  • next(iterator) si vezme další prvek.

Když už žádný další prvek není, next vyhodí výjimku StopIteration. Není to chyba v pravém smyslu, jen signál „došly stránky“.

ovoce = ["jablko", "hruška"]

zalozka = iter(ovoce)
print(next(zalozka))
print(next(zalozka))
print(next(zalozka))
Výstup
jablko
hruška

Třetí next už nemá co vrátit, proto ukázka končí výjimkou. S touhle znalostí přepíšeš for ručně. Přesně tohle za tebe Python dělá při každém cyklu:

barvy = ["červená", "zelená", "modrá"]

iterator = iter(barvy)
while True:
    try:
        barva = next(iterator)
    except StopIteration:
        break
    print(barva)
Výstup
červená
zelená
modrá

Díky tomu funguje for se vším, co se umí domluvit přes tyhle dvě funkce. A nejen for: stejně si data berou list(), sum(), max(), sorted(), rozbalování a, b = x i * ve volání funkce.

Úkol

První prvek, nebo náhrada

Napiš funkci prvni(data, vychozi=None). Vrátí první prvek z data. Když jsou data prázdná, vrátí vychozi. Musí fungovat pro seznam, range i pro iterátor a z iterátoru smí odebrat jen jeden prvek. Pozor na prvky jako 0 nebo None, i ty jsou platný první prvek.

def prvni(data, vychozi=None):
    # doplň
    pass
Výstup
Pod kapotou · for v bytecodu

Cyklus se přeloží na pár instrukcí. GET_ITER zavolá ekvivalent iter() a FOR_ITER při každém průchodu ekvivalent next().

import dis

kod = compile("for x in data:\n    pass", "<ukazka>", "exec")
hledane = {"GET_ITER", "FOR_ITER", "STORE_NAME", "JUMP_BACKWARD", "END_FOR"}
for instrukce in dis.get_instructions(kod):
    if instrukce.opname in hledane:
        print(instrukce.opname)
Výstup
GET_ITER
FOR_ITER
STORE_NAME
JUMP_BACKWARD
END_FOR

Iterátory psané v C vracejí ze slotu tp_iternext hodnotu NULL a výjimku vůbec nemusí vytvářet, takže běžný konec cyklu nad seznamem žádný objekt StopIteration nealokuje. Adaptivní interpret (PEP 659) navíc FOR_ITER za běhu specializuje na FOR_ITER_LIST, FOR_ITER_TUPLE, FOR_ITER_RANGE a FOR_ITER_GEN. Třída s __next__ v Pythonu tuhle zkratku nemá: každý krok je plné volání metody a konec je opravdová výjimka. Protokol zavedl PEP 234.

Iterable a iterátor nejsou totéž

Tyhle dva pojmy se pletou i lidem, kteří programují roky.

  • Iterable je cokoli, co umí vyrobit iterátor. Má metodu __iter__. Patří sem seznam, n-tice, řetězec, slovník, množina nebo range.
  • Iterátor je objekt, který si pamatuje pozici. Má __next__ a jeho __iter__ vrací jeho samotného.

Metody s dvojitým podtržítkem znáš z lekce Speciální metody a datový model. Funkce iter(x) volá x.__iter__() a next(x) volá x.__next__().

cisla = [10, 20, 30]

a = iter(cisla)
b = iter(cisla)

print(next(a))
print(next(a))
print(next(b))

print("a je b:", a is b)
print("iter(a) je a:", iter(a) is a)
print("iter(cisla) je cisla:", iter(cisla) is cisla)
Výstup
10
20
10
a je b: False
iter(a) je a: True
iter(cisla) je cisla: False

Seznam vydal dvě nezávislé záložky. a je na třetím prvku, b teprve na druhém a samotnému seznamu se nic nestalo.

Iterátor naproti tomu jde projít jen jednou. Vrací ho map, filter, zip, enumerate, reversed i otevřený soubor. Druhý průchod nevyhodí chybu, prostě nic nedá, a proto se tahle chyba hledá tak těžko.

ceny = [100, 250, 80]
dvojnasobek = map(lambda c: c * 2, ceny)

print(list(dvojnasobek))
print(list(dvojnasobek))
print(sum(dvojnasobek))
Výstup
[200, 500, 160]
[]
0
Kvíz

Co vypíše r = range(3) a potom print(list(r), list(r))?

Kvíz

Který objekt má vlastnost iter(x) is x?

Vlastní iterátor

Stačí třída se dvěma metodami. __iter__ vrátí self, __next__ vrátí další hodnotu, nebo vyhodí StopIteration.

class Odpocet:
    def __init__(self, start):
        self.zbyva = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.zbyva <= 0:
            raise StopIteration
        hodnota = self.zbyva
        self.zbyva -= 1
        return hodnota


odpocet = Odpocet(3)
for cislo in odpocet:
    print(cislo)

print("znovu:", list(odpocet))
Výstup
3
2
1
znovu: []

Objekt se chová jako každý jiný iterátor, včetně toho, že podruhé už nedá nic. Stav je totiž uložený přímo v něm.

Úkol

Iterátor s krokem

Napiš třídu Kroky(start, stop, krok), která je iterátorem. Vydává start, start + krok a tak dál, dokud je hodnota menší než stop. list(Kroky(0, 10, 3)) dá [0, 3, 6, 9].

class Kroky:
    def __init__(self, start, stop, krok):
        self.dalsi = start
        self.stop = stop
        self.krok = krok

    # doplň __iter__ a __next__
Výstup

Objekt, který jde projít opakovaně

Odpočet je jednorázový. Playlist by takový být neměl: chceš ho pustit znovu a klidně ho procházet dvakrát najednou. Řešení je rozdělit role. Kolekce je iterable a při každém iter() vyrobí nový iterátor s vlastní pozicí.

class Playlist:
    def __init__(self, skladby):
        self.skladby = list(skladby)

    def __iter__(self):
        return PlaylistIterator(self.skladby)


class PlaylistIterator:
    def __init__(self, skladby):
        self.skladby = skladby
        self.pozice = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.pozice >= len(self.skladby):
            raise StopIteration
        skladba = self.skladby[self.pozice]
        self.pozice += 1
        return skladba


playlist = Playlist(["Intro", "Refrén"])
print(list(playlist))
print(list(playlist))

for prvni in playlist:
    for druha in playlist:
        print(prvni, "->", druha)
Výstup
['Intro', 'Refrén']
['Intro', 'Refrén']
Intro -> Intro
Intro -> Refrén
Refrén -> Intro
Refrén -> Refrén

Vnořené cykly fungují jen proto, že každý má vlastní záložku. Kdyby __iter__ vracelo self, vnitřní cyklus by vyčerpal i ten vnější.

Úkol

Trasa tam a zpět

Napiš třídu TamZpet(zastavky). Při procházení vydá zastávky popořadě a potom zpět bez opakování té poslední: pro ["A", "B", "C"] je to A, B, C, B, A. Objekt musí jít projít opakovaně i ve dvou vnořených cyklech.

class TamZpet:
    def __init__(self, zastavky):
        self.zastavky = list(zastavky)

    def __iter__(self):
        # doplň
        return iter(self.zastavky)
Výstup

Dvě málo známé podoby iter a next

next přijímá druhý argument: co vrátit, když prvky došly. Výjimka pak nenastane. V kombinaci s filter je z toho čisté „najdi první, co vyhovuje“, které se zastaví hned u shody.

teploty = [18, 21, 34, 19, 36]

prvni_horko = next(filter(lambda t: t > 30, teploty), None)
prvni_mraz = next(filter(lambda t: t < 0, teploty), None)

print(prvni_horko)
print(prvni_mraz)
Výstup
34
None

Také iter má druhou podobu: iter(funkce, zarazka). Volá funkci bez argumentů tak dlouho, dokud nevrátí hodnotu zarazka. Hodí se na všechno, co se čte po kouscích.

nakup = list(iter(input, "konec"))
print(nakup)
Výstup
['mléko', 'chleba']
Pod kapotou · záložní cesty a smlouva iterátoru

iter(x) hledá __iter__ na typu. Když ho nenajde, zkusí starší sekvenční protokol: volá __getitem__(0), __getitem__(1) a tak dál do IndexError. Proto test přes collections.abc.Iterable lže.

from collections.abc import Iterable


class Stara:
    def __getitem__(self, index):
        if index >= 3:
            raise IndexError
        return index * 10


objekt = Stara()
print(list(objekt))
print(isinstance(objekt, Iterable))
print(type(iter(objekt)).__name__)
Výstup
[0, 10, 20]
False
iterator

Spolehlivý test je jen zavolat iter(x) a chytit TypeError, což doporučuje i dokumentace. Naopak __iter__ = None ve třídě iterování výslovně zakáže a záložní cestu vypne. Podobně in zkouší __contains__, pak __iter__, pak __getitem__, odtud to tiché vyčerpání iterátoru.

Dokumentace dále říká, že iterátor, který jednou vyhodil StopIteration, ji musí vyhazovat i dál, jinak je „rozbitý“. Iterátor seznamu to řeší tak, že po dojetí zahodí odkaz na seznam, takže se neprobudí, ani když do seznamu později přidáš prvky. Vlastní iterátory čtoucí z fronty tohle pravidlo často porušují a zip nebo chain se pak chovají nepředvídatelně.

Iterátor může přes __length_hint__ (PEP 424, čte operator.length_hint) napovědět odhad délky. list() podle něj předem alokuje místo. Je to jen rada a správnost na ní stát nesmí.