Generatorfunktioner
Skapa värden lat fördröjt med yield
Generatorfunktioner är en gratis lektion i Python Academy på CoddyKit. Detta är lektion 2 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 en generator?
En generatorfunktion ser ut som en vanlig funktion men använder yield i stället för, eller tillsammans med, return. När du anropar den körs inte funktionskroppen; i stället returneras ett generatorobjekt, som är en iterator.
def gen():
yield 1
yield 2
yield 3
g = gen()
print(type(g).__name__)
print(list(g))yield pausar körningen
Varje gång du anropar next() körs funktionen tills den når ett yield, returnerar det värdet och fryser sitt tillstånd. Nästa anrop fortsätter direkt efter yield.
def steps():
print('start')
yield 'a'
print('resumed')
yield 'b'
g = steps()
print(next(g))
print(next(g))Iterera över en generator
Eftersom en generator är en iterator driver en for-loop den automatiskt och slutar när funktionen avslutas, vilket internt utlöser StopIteration.
def countdown(n):
while n > 0:
yield n
n -= 1
for x in countdown(4):
print(x)Lat utvärdering
Generatorer är lata: värden produceras bara när de efterfrågas. Det innebär att du kan modellera mycket stora eller oändliga sekvenser utan att använda stora mängder minne.
def naturals():
n = 1
while True:
yield n
n += 1
g = naturals()
print(next(g), next(g), next(g))Tillstånd mellan yield-anrop
Lokala variabler behåller sina värden mellan yield-punkter. En generator kommer automatiskt ihåg var den slutade, utan att du behöver hålla reda på något index manuellt.
def fib():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
g = fib()
print([next(g) for _ in range(7)])Generatorer jämfört med att skapa en lista
En vanlig funktion bygger och returnerar hela listan på en gång. En generator ger värden allt eftersom de efterfrågas. Använd en generator när sekvensen är stor eller när du kanske slutar iterera tidigt.
def squares_list(n):
result = []
for i in range(n):
result.append(i * i)
return result
def squares_gen(n):
for i in range(n):
yield i * i
print(squares_list(5))
print(list(squares_gen(5)))Stoppa tidigt
Eftersom värden produceras på begäran kan du lämna en loop med break, så beräknar generatorn helt enkelt aldrig resten.
def naturals():
n = 1
while True:
print('producing', n)
yield n
n += 1
for x in naturals():
if x > 3:
break
print('got', x)return i en generator
Ett ensamt return i en generator avslutar den helt enkelt och utlöser StopIteration. Alla värden du returnerar blir undantagets attribut value, som de flesta loopar ignorerar.
def up_to(stop):
i = 0
while True:
if i >= stop:
return
yield i
i += 1
print(list(up_to(4)))Generatorer kan bara användas en gång
Precis som alla iteratorer förbrukas en generator en gång. När den är uttömd ger den inga fler värden. Anropa funktionen igen för att få en ny generator.
def gen():
yield 1
yield 2
g = gen()
print(list(g))
print(list(g))
print(list(gen()))Filtrering med generatorer
Generatorer gör det enkelt att skapa tydliga datapipelines. Här ger vi bara de jämna talen, ett i taget.
def evens(numbers):
for n in numbers:
if n % 2 == 0:
yield n
print(list(evens(range(10))))Kedja generatorer
En generator kan förbruka en annan generator och på så sätt bygga en pipeline i flera steg där varje steg är lat.
def numbers(n):
for i in range(n):
yield i
def doubled(src):
for x in src:
yield x * 2
print(list(doubled(numbers(5))))Snabbtest
Testa din förståelse av generatorfunktioner.
Sammanfattning
Du har lärt dig om generatorfunktioner:
yieldpausar och återupptar körningen och bevarar det lokala tillståndet.- Ett anrop av funktionen returnerar ett lat generatorobjekt.
- De använder lite minne och passar utmärkt för pipelines och oändliga dataströmmar.
- De kan bara användas en gång, precis som alla iteratorer.
Härnäst: de ännu mer kompakta generatoruttrycken.
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
Vanliga frågor
Är lektionen ”Generatorfunktioner” gratis?
Ja – hela texten till ”Generatorfunktioner” 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 ”Generatorfunktioner”?
Skapa värden lat fördröjt med yield 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 2 av 4.
Hur lång tid tar lektionen ”Generatorfunktioner”?
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
- Iteratorprotokollet
- Generatorfunktioner
- Generatorexpressioner
- yield from och delegering