Python Academy · Lektion

Iteratorprotokollet

Förstå __iter__ och __next__

Lektion 1 av 413 steg

Iteratorprotokollet är en gratis lektion i Python Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Python Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Python Academy innehåller totalt 4 lektioner.

Vad är iteration?

Varje gång ni skriver en for-loop över en lista, sträng eller ett dict-objekt använder Python iteratorprotokollet i bakgrunden.

Ett objekt som ni kan loopa över kallas itererbart. Det som faktiskt producerar värden ett i taget kallas en iterator.

for ch in 'abc':
    print(ch)

iter() och next()

Två inbyggda funktioner driver iterationen:

iter(obj) ber ett itererbart objekt om dess iterator.
next(it) ber iteratorn om nästa värde.

När det inte finns fler värden genererar next() ett StopIteration-undantag.

it = iter([10, 20, 30])
print(next(it))
print(next(it))
print(next(it))

StopIteration

Om ni anropar next() en gång för mycket genereras StopIteration. En for-loop fångar detta automatiskt och avslutas på ett ordnat sätt.

it = iter([1])
print(next(it))
try:
    next(it)
except StopIteration:
    print('No more items')

De två dunder-metoderna

För att skapa en egen iterator implementerar ni två metoder:

__iter__ returnerar själva iteratorobjektet.
__next__ returnerar nästa värde eller genererar StopIteration.

class Count:
    def __init__(self, n):
        self.i = 0
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= self.n:
            raise StopIteration
        self.i += 1
        return self.i

for x in Count(3):
    print(x)

Itererbart objekt kontra iterator

Ett itererbart objekt behöver bara __iter__. En iterator behöver både __iter__ och __next__.

Listor är itererbara men inte iteratorer: varje anrop till iter() ger en ny iterator.

nums = [1, 2, 3]
print(iter(nums) is iter(nums))
it = iter(nums)
print(it is iter(it))

Iteratorer förbrukas en gång

En iterator kan förbrukas endast en gång. När ni har nått slutet förblir den tom. Skapa en ny iterator om ni vill loopa igen.

it = iter([1, 2])
print(list(it))
print(list(it))

En range-liknande iterator

Vi bygger en anpassad iterator som fungerar som en enkel räknare. Lägg märke till att tillståndet finns i instansen.

class EvenUpTo:
    def __init__(self, limit):
        self.cur = 0
        self.limit = limit
    def __iter__(self):
        return self
    def __next__(self):
        if self.cur > self.limit:
            raise StopIteration
        value = self.cur
        self.cur += 2
        return value

print(list(EvenUpTo(8)))

Separera itererbart objekt och iterator

En renare design håller behållaren och iteratorn separerade, så att behållaren kan loopas över flera gånger.

class Bag:
    def __init__(self, items):
        self.items = items
    def __iter__(self):
        return BagIterator(self.items)

class BagIterator:
    def __init__(self, items):
        self.items = items
        self.i = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= len(self.items):
            raise StopIteration
        v = self.items[self.i]
        self.i += 1
        return v

b = Bag(['x', 'y'])
print(list(b))
print(list(b))

Använda next() med ett standardvärde

next(it, default) returnerar standardvärdet i stället för att generera StopIteration när iteratorn är tom. Praktiskt för säker förhandsgranskning.

it = iter([42])
print(next(it, 'done'))
print(next(it, 'done'))

Iteratorer är minnessnåla

Iteratorer ger ett objekt i taget, så de behöver inte hålla hela sekvensen i minnet. Därför fungerar de även för mycket stora eller till och med oändliga dataströmmar.

class Naturals:
    def __init__(self):
        self.n = 0
    def __iter__(self):
        return self
    def __next__(self):
        self.n += 1
        return self.n

it = iter(Naturals())
print(next(it), next(it), next(it))

Inbyggda funktioner som förbrukar iteratorer

Många inbyggda funktioner accepterar valfri iterator: sum, max, min, sorted, list och tuple. De hämtar värden tills StopIteration inträffar.

class Count:
    def __init__(self, n):
        self.i = 0
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= self.n:
            raise StopIteration
        self.i += 1
        return self.i

print(sum(Count(5)))
print(max(Count(5)))

Snabbtest

Testa din förståelse av iteratorprotokollet.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig iteratorprotokollet:

iter() hämtar en iterator och next() hämtar värden.
StopIteration signalerar slutet och for hanterar det.
Anpassade iteratorer implementerar __iter__ och __next__.
Iteratorer kan bara användas en gång och använder lite minne.

Härnäst får du låta Python skriva iteratorer åt dig med yield.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 76
Lektioner: 320

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Iteratorprotokollet” gratis?

Ja – hela texten till ”Iteratorprotokollet” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Python Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Python Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Iteratorprotokollet”?

Förstå __iter__ och __next__ Ni övar på Python Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Python Academy?

Du behöver inga förkunskaper. Utbildningen i Python Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Iteratorprotokollet”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Python Academy-lektionen?

Ja. Varje Python Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Python Academy