Python Academy · Les

Het iteratorprotocol

Begrijp __iter__ en __next__

Les 1 van 413 stappen

Het iteratorprotocol is een gratis Python Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Python Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Python Academy bevat in totaal 4 lessen.

Wat is iteratie?

Elke keer dat je een for-lus over een lijst, tekenreeks of woordenboek schrijft, gebruikt Python achter de schermen het iteratorprotocol.

Een object waarover je kunt lussen heet een iterable. Datgene wat daadwerkelijk één voor één waarden produceert, heet een iterator.

for ch in 'abc':
    print(ch)

iter() en next()

Twee ingebouwde functies sturen iteratie aan:

iter(obj) vraagt een iterable om zijn iterator.
next(it) vraagt de iterator om de volgende waarde.

Wanneer er geen waarden meer zijn, veroorzaakt next() een StopIteration.

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

StopIteration

Als je één keer te vaak next() aanroept, ontstaat een StopIteration. Een for-lus vangt dit automatisch op en stopt netjes.

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

De twee dunder-methoden

Om je eigen iterator te maken, implementeer je twee methoden:

__iter__ retourneert het iteratorobject zelf.
__next__ retourneert de volgende waarde of veroorzaakt een 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)

Iterable versus iterator

Een iterable heeft alleen __iter__ nodig. Een iterator heeft zowel __iter__ als __next__ nodig.

Lijsten zijn iterables maar geen iterators: elke aanroep van iter() levert een nieuwe iterator op.

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

Iterators raken maar één keer uitgeput

Je kunt een iterator maar één keer verbruiken. Nadat je het einde hebt bereikt, blijft hij leeg. Als je opnieuw wilt lussen, maak je een nieuwe iterator.

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

Een range-achtige iterator

Laten we een aangepaste iterator bouwen die zich gedraagt als een eenvoudige teller. Let op hoe de toestand in de instantie wordt bewaard.

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

Iterable en iterator scheiden

Een netter ontwerp houdt de container en de iterator gescheiden, zodat je de container meerdere keren kunt doorlopen.

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

next() gebruiken met een standaardwaarde

next(it, default) retourneert de standaardwaarde in plaats van een StopIteration te veroorzaken wanneer de iterator leeg is. Handig om veilig vooruit te kijken.

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

Iterators zijn zuinig met geheugen

Iterators leveren één element tegelijk op, dus ze hoeven niet de hele reeks in het geheugen te bewaren. Daarom zijn ze geschikt voor enorme of zelfs oneindige gegevensstromen.

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

Ingebouwde functies die iterators verbruiken

Veel ingebouwde functies accepteren elke iterator: sum, max, min, sorted, list en tuple. Ze halen waarden op totdat StopIteration optreedt.

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

Korte controle

Controleer of je het iteratorprotocol begrijpt.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt het iteratorprotocol geleerd:

iter() haalt een iterator op; next() haalt waarden op.
StopIteration geeft het einde aan en for handelt dit af.
Aangepaste iterators implementeren __iter__ en __next__.
Iterators kun je maar één keer gebruiken en ze zijn zuinig met geheugen.

Vervolgens laat je Python iterators voor je schrijven met yield.

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 76
Lessen: 320

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Het iteratorprotocol” gratis?

Ja — de volledige tekst van “Het iteratorprotocol” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Python Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Python Academy bevat in totaal 4 lessen.

Wat leer ik in “Het iteratorprotocol”?

Begrijp __iter__ en __next__ Je oefent met Python Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Python Academy te beginnen?

Ervaring vooraf is niet nodig. Python Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Het iteratorprotocol”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Python Academy?

Ja. Elke les over Python Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Python Academy