Iteratorer i Python

Denne artikel forklarer iteratorer i Python.

YouTube Video

Iteratorer i Python

Oversigt

I Python er en iterator en grundlæggende mekanisme til at behandle elementer i samlinger som lister, tupler og ordbøger ét ad gangen.

Hvad er en Iterator?

En iterator er et objekt, der kan returnere elementer ét ad gangen. I Python anses et objekt for at være en iterator, hvis det opfylder følgende to betingelser:.

• Det har en __iter__() metode, der returnerer sig selv.
• Det har en __next__() metode, der returnerer det næste element. Det rejser StopIteration, når der ikke er flere elementer.

1iterator = iter([1, 2, 3])
2print(next(iterator))  # 1
3print(next(iterator))  # 2
4print(next(iterator))  # 3
5# print(next(iterator))  # StopIteration occurs

• I denne kode bruges iter()-funktionen til at konvertere en liste til en iterator, og next()-funktionen bruges til at hente og vise hvert element én efter én.

Forskel fra Iterable

Et iterable er et objekt, der implementerer metoden __iter__() og kan bruges i en for-løkke. Lister og tupler er eksempler på iterables.

1nums = [10, 20, 30]
2it = iter(nums)  # Get an iterator from the iterable
3print(next(it))  # 10

• Denne kode er et eksempel på at opnå en iterator fra en iterabel som en liste og hente elementer i rækkefølge med next().

Sådan tjekker du:

1from collections.abc import Iterable, Iterator
2
3nums = [10, 20, 30]
4it = iter(nums)
5
6print(isinstance(nums, Iterable))  # True
7print(isinstance(nums, Iterator))  # False
8print(isinstance(it, Iterator))    # True

• Denne kode bekræfter, at nums er en iterabel, men ikke en iterator, mens it, opnået ved at bruge iter(nums), er en iterator.

Forholdet mellem for-løkker og iteratorer

En for-løkke i Python fungerer internt således:.

1nums = [1, 2, 3]
2iterator = iter(nums)
3while True:
4    try:
5        value = next(iterator)
6        print(value)
7    except StopIteration:
8        break

• Som vist anvender for-løkken implicit en iterator til at udføre iterationen.

Oprettelse af en brugerdefineret iterator

Du kan oprette en brugerdefineret iterator ved at bruge en klasse.

 1class Countdown:
 2    def __init__(self, start):
 3        self.current = start
 4
 5    def __iter__(self):
 6        return self
 7
 8    def __next__(self):
 9        if self.current <= 0:
10            raise StopIteration
11        value = self.current
12        self.current -= 1
13        return value
14
15for num in Countdown(3):
16    print(num)  # 3, 2, 1

• Denne kode definerer en brugerdefineret iterator, der tæller ned ved hjælp af Countdown-klassen og udskriver tal fra 3 til 1 ved hjælp af en for-løkke.

Forskellen mellem iteratorer og generatorer, og hvornår man skal bruge hver

Generatorer giver funktionalitet, der ligner iteratorers. De gør det muligt at definere iteratorer mere kortfattet.

1def countdown(n):
2    while n > 0:
3        yield n
4        n -= 1
5
6for i in countdown(3):
7    print(i)  # 3, 2, 1

• Denne kode definerer en generatorfunktion, der tæller ned ved hjælp af yield, og udskriver tal fra 3 til 1 ved hjælp af en for-løkke.

Forskelle mellem iteratorer (klasse) og generatorer (funktion)

Der er følgende forskelle mellem iteratorer (klasser) og generatorer (funktioner):.

• Forskel i hvordan de defineres En iterator defineres ved manuelt at skrive to metoder: __iter__() og __next__(). I modsætning hertil er en generator blot en funktion, der anvender yield-nøgleordet, hvilket gør koden meget enklere.

• Forskel i tilstandshåndtering Med en iterator skal du selv holde styr på den nuværende tilstand og fremdrift ved hjælp af variable. Generatorer bevarer dog automatisk deres tilstand internt i Python, hvilket reducerer det manuelle arbejde.

• Kode-læsbarhed Iteratorer har tendens til at blive komplekse, fordi de kræver flere metoder og manuel tilstandshåndtering. Generatorer bruger derimod en simpel syntaks, hvilket gør dem lettere at forstå, selv for begyndere.

Standardbibliotek til brug af iteratorer: itertools

itertools, et standard Python-bibliotek, giver kraftfulde værktøjer til at arbejde med iteratorer.

1import itertools
2
3for x in itertools.count(10, 2):  # 10, 12, 14, ...
4    if x > 20:
5        break
6    print(x)

• Det indeholder også mange andre funktioner som cycle, repeat, chain, islice og tee.

Brugsområder for iteratorer

Brugstilfælde for iteratorer omfatter følgende:.

• Behandling af fil-linjer: Læs linjer én ad gangen fra en fil som en iterator.
• Hukommelseseffektiv behandling: Behandl store datamængder sekventielt.
• Repræsentation af uendelige sekvenser: Brug funktioner som itertools.count().

Sammendrag

• En iterator er et objekt, der kan indhente den næste værdi sekventielt.
• Du kan oprette en brugerdefineret iterator ved at definere __iter__() og __next__().
• De håndteres automatisk via for-løkker eller funktionen next().
• Brug af generatorer eller itertools muliggør mere effektiv behandling.

Ved at bruge iteratorer kan du behandle store datamængder sekventielt på en hukommelseseffektiv måde, hvilket muliggør kontrolleret tilstandsstyring og forbedret programmets ydeevne.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video