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))
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)
č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.
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
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)
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 neborange. - 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)
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))
[200, 500, 160] [] 0
Co vypíše r = range(3) a potom print(list(r), list(r))?
range je iterable, ne iterátor. Pamatuje si jen začátek, konec a krok a pro každý průchod vydá nový iterátor. Proto ho můžeš procházet, kolikrát chceš.
Který objekt má vlastnost iter(x) is x?
zip vrací iterátor a iterátor při iter() vrací sám sebe. Seznam, řetězec a range jsou iterable a pokaždé vyrobí nový iterátor.
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))
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.
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__
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)
['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ší.
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)
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)
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)
['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__)
[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í.