Python Academy · Lektion

Iterator-protokollen

Forstå __iter__ og __next__

Lektion 1 af 413 trin

Iterator-protokollen er en gratis Python Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Python Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Python Academy-kurset indeholder 4 lektioner i alt.

Hvad er iteration?

Hver gang du skriver en for-løkke over en liste, streng eller ordbog, bruger Python iteratorprotokollen i baggrunden.

Et objekt, som du kan gennemløbe, kaldes et iterabelt objekt. Det, der faktisk producerer værdier én ad gangen, kaldes en iterator.

for ch in 'abc':
    print(ch)

iter() og next()

To indbyggede funktioner driver iteration:

iter(obj) beder et iterabelt objekt om dets iterator.
next(it) beder iteratoren om den næste værdi.

Når der ikke er flere værdier, udløser next() StopIteration.

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

StopIteration

Hvis du kalder next() én gang for meget, udløses StopIteration. En for-løkke håndterer automatisk dette og stopper korrekt.

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

De to dunder-metoder

For at oprette din egen iterator skal du implementere to metoder:

__iter__ returnerer selve iteratorobjektet.
__next__ returnerer den næste værdi eller udløser 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)

Iterabel kontra iterator

Et iterabelt objekt behøver kun __iter__. En iterator behøver både __iter__ og __next__.

Lister er iterabler, men ikke iteratorer: Hvert kald til iter() giver en ny iterator.

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

Iteratorer tømmes kun én gang

En iterator kan kun gennemløbes én gang. Når du når slutningen, forbliver den tom. Opret en ny iterator for at gennemløbe den igen.

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

En intervalslignende iterator

Lad os oprette en brugerdefineret iterator, der fungerer som en simpel tæller. Bemærk, hvordan tilstanden ligger 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)))

Adskillelse af iterabelt objekt og iterator

Et renere design holder beholderen og iteratoren adskilt, så beholderen kan gennemløbes mange gange.

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))

Brug af next() med en standardværdi

next(it, default) returnerer standardværdien i stedet for at udløse StopIteration, når iteratoren er tom. Det er praktisk, når du vil kigge sikkert fremad.

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

Iteratorer er hukommelsesvenlige

Iteratorer leverer ét element ad gangen, så de behøver ikke at holde hele sekvensen i hukommelsen. Derfor kan de håndtere meget store eller endda uendelige datastrømme.

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))

Indbyggede funktioner, der gennemløber iteratorer

Mange indbyggede funktioner accepterer enhver iterator: sum, max, min, sorted, list, tuple. De henter værdier, indtil 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

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

Hurtigt tjek

Tjek din forståelse af iteratorprotokollen.

Besvar den i den interaktive lektion

Opsummering

Du har lært iteratorprotokollen:

iter() henter en iterator, og next() henter værdier.
StopIteration angiver slutningen, og for håndterer den.
Brugerdefinerede iteratorer implementerer __iter__ og __next__.
Iteratorer kan kun bruges én gang og er hukommelsesvenlige.

Nu skal du lade Python skrive iteratorer for dig med yield.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 76
Lektioner: 320

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Iterator-protokollen” gratis?

Ja — hele teksten til “Iterator-protokollen” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Python Academy-kurset, skal du opgradere til CoddyKit PRO. Python Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Iterator-protokollen”?

Forstå __iter__ og __next__ Du øver dig i Python Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Python Academy?

Der kræves ingen tidligere erfaring. Python Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Iterator-protokollen”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Python Academy-lektion?

Ja. Alle Python Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Python Academy