Wyobraź sobie, że ładujesz plik dziennika o rozmiarze 10 GB na listę tylko po to, aby znaleźć błędy. Twojemu programowi może zabraknąć pamięci, zanim ją znajdzie. Generatory Pythona rozwiązują ten problem, tworząc wartości na żądanie, pojedynczo, dzięki czemu możesz pracować z ogromnymi, a nawet nieskończonymi danymi, prawie bez pamięci.

Ten przewodnik pokazuje krok po kroku, co naprawdę dzieje się, gdy generator działa. Każdy przykład uruchomiliśmy w Pythonie 3.13, a dane wyjściowe pochodzą z tego uruchomienia. Pomaga już opanowanie funkcji i pętli, które omawiamy w naszym samouczku Pythona dla początkujących.

Co to jest generator?

Generator to specjalny rodzaj iteratora, który tworzysz, pisząc funkcję za pomocą yield. Każda funkcja zawierająca yield automatycznie staje się funkcją generatora, a jej wywołanie daje obiekt generatora zamiast uruchamiania kodu.

def count_up(limit):
    print("starting")
    n = 1
    while n <= limit:
        yield n
        n += 1
    print("finished")

gen = count_up(2)
print(gen)

# <generator object count_up at 0x...>

Zauważ, że komunikat „start” nie został wydrukowany. Wywołanie funkcji spowodowało jedynie utworzenie generatora. Nic w środku jeszcze się nie uruchomiło.

Jak działa wydajność, krok po kroku

Każde wywołanie next() uruchamia funkcję aż do osiągnięcia yield, przekazuje tę wartość i zawiesza się w miejscu. Następne wywołanie zostanie wznowione zaraz po tej linii, z nienaruszoną każdą zmienną lokalną.

print(next(gen))
# starting
# 1

print(next(gen))
# 2

next(gen)
# finished
# StopIteration

Uważnie postępuj zgodnie z wynikami. „start” pojawia się tylko na pierwszym next(). W drugim przypadku wykonywanie jest kontynuowane od miejsca, w którym zostało zatrzymane, więc n jest nadal dostępne i wynosi 2. W trzecim przypadku pętla się kończy, następuje wypisanie komunikatu „zakończonego”, funkcja kończy się, a Python podnosi StopIteration, aby zasygnalizować, że nic już nie zostało.

Sam rzadko dzwonisz do next(). Pętla for robi to za Ciebie i obsługuje StopIteration cicho, podobnie jak list(), sum() i podobne funkcje:

print(list(count_up(3)))

# starting
# finished
# [1, 2, 3]

zysk vs zwrot

To opóźnienie jest znane jako leniwa ocena: wartości są opracowywane tylko wtedy, gdy jest to potrzebne. Zwykły return wewnątrz generatora po prostu go kończy, co uruchamia StopIteration.

Zmierzona różnica w pamięci

Porównaliśmy listę miliona kwadratów z równoważnym generatorem, używając sys.getsizeof:

import sys

squares_list = [n * n for n in range(1_000_000)]
squares_gen = (n * n for n in range(1_000_000))

print(sys.getsizeof(squares_list), sys.getsizeof(squares_gen))

# 8448728 200

Własna struktura listy zajmowała około 8,4 MB, podczas gdy generator w naszym systemie zajmował zaledwie 200 bajtów. Rzeczywista różnica jest jeszcze większa, ponieważ getsizeof nie zlicza obiektów całkowitych na liście. Rozmiar generatora również pozostaje taki sam dla miliarda elementów, ponieważ przechowuje on tylko swój aktualny stan, a nie wyniki.

Istnieje jednak kompromis. Listę można ponownie wykorzystać, indeksować i mierzyć za pomocą len(). Generator nie oferuje żadnego z nich. Jeśli potrzebujesz dostępu losowego lub będziesz wykonywać pętlę kilka razy na małej ilości danych, lista jest prostsza. Zobacz nasz przewodnik po Lista Pythona vs Tuple vs Set, aby uzyskać więcej informacji na temat tych typów.

Wyrażenia generatora

W prostych przypadkach nie potrzebujesz funkcji. Wyrażenie generatora wygląda jak zrozumienie listowe z nawiasami okrągłymi zamiast kwadratowych:

squares = [n * n for n in range(5)]   # builds a list now
squares = (n * n for n in range(5))   # produces values on demand

print(sum(n * n for n in range(5)))

# 30

Gdy wyrażenie generatora jest jedynym argumentem funkcji, jak w sum(), możesz pominąć dodatkowe nawiasy. Jest to dobry zwyczaj w przypadku sum obejmujących duże ilości danych, ponieważ nie jest tworzona żadna lista tymczasowa.

Zbuduj potok danych

To tutaj generatory naprawdę świecą. Małe generatory można łączyć w łańcuchy, dzięki czemu każdy element przechodzi przez każdy etap, jeden po drugim:

def read_lines(lines):
    for line in lines:
        yield line.strip()

def only_errors(lines):
    for line in lines:
        if line.startswith("ERROR"):
            yield line

def messages(lines):
    for line in lines:
        yield line.split(" ", 1)[1]

log = ["INFO started\n", "ERROR db down\n",
       "ERROR disk full\n", "INFO stopped\n"]

print(list(messages(only_errors(read_lines(log)))))

# ['db down', 'disk full']

Każdy krok wykonuje jedną małą pracę i można go przetestować samodzielnie. W rzeczywistym użyciu zamień przykładową listę na otwarty plik, ponieważ obiekty plików można czytać linia po linii, jak pokazuje nasz przewodnik po obsłudze plików w Pythonie. Nawet wielogigabajtowy dziennik zostałby wówczas przesłany z bardzo małą ilością pamięci.

Nieskończone sekwencje

Lista nie może być nieskończona, ale generator może, ponieważ oblicza tylko następną wartość. Użyj itertools.islice, aby wziąć tyle, ile potrzebujesz:

import itertools

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

print(list(itertools.islice(fibonacci(), 8)))

# [0, 1, 1, 2, 3, 5, 8, 13]

Bądź jednak ostrożny: wywołanie list(fibonacci()) bez limitu będzie trwało, dopóki nie zniknie twoja pamięć. Ten sam wzorzec pasuje do generatorów identyfikatorów, pętli odpytywania i stronicowanych wyników API, w przypadku których następną stronę można pobrać dopiero wtedy, gdy bieżąca się skończy.

uzysk z i partii

yield from przekazuje inną iterację, oszczędzając zagnieżdżoną pętlę:

def chain_all(*groups):
    for group in groups:
        yield from group

print(list(chain_all([1, 2], (3, 4))))

# [1, 2, 3, 4]

Bardzo praktycznym wzorcem jest dzielenie danych na partie o stałym rozmiarze, na przykład w celu wstawienia tysiąca wierszy do bazy danych na raz:

def batches(items, size):
    batch = []
    for item in items:
        batch.append(item)
        if len(batch) == size:
            yield batch
            batch = []
    if batch:
        yield batch

print(list(batches(range(7), 3)))

# [[0, 1, 2], [3, 4, 5], [6]]

Ostatnia if batch zapewnia, że mniejsza grupa resztek nie zostanie utracona. Python 3.12 i nowsze wersje zawierają także itertools.batched, który wykonuje podobne zadanie.

wyślij, zamknij i wyczyść

Generatory mogą również odbierać wartości. send() wznawia generator, a wartość staje się wynikiem wyrażenia yield. Najpierw musisz zadzwonić do next(), aby dotrzeć do pierwszego yield:

def running_total():
    total = 0
    while True:
        value = yield total
        total += value

t = running_total()
next(t)
print(t.send(10), t.send(5))

# 10 15

Większość ludzi rzadko tego potrzebuje. Częściej spotykanym problemem jest sprzątanie. Jeśli zatrzymasz się wcześniej, blok finally będzie nadal działać, gdy generator zostanie zamknięty:

def tracked():
    try:
        yield 1
        yield 2
    finally:
        print("cleanup ran")

tr = tracked()
next(tr)
tr.close()

# cleanup ran

Pytest wykorzystuje ten sam pomysł: urządzenie z yield uruchamia później czyszczenie, jak pokazuje nasz samouczek pytest. Podobnie dekorator contextmanager biblioteki standardowej zamienia generator w blok with.

Generatory na zajęciach

Napisanie metody __iter__ jako generatora to najłatwiejszy sposób na umożliwienie iteracji własnej klasy. Dodatkową zaletą jest to, że każda pętla otrzymuje nowy generator, dzięki czemu obiekt można zapętlać wielokrotnie:

class Countdown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        n = self.start
        while n > 0:
            yield n
            n -= 1

c = Countdown(3)
print(list(c), list(c))

# [3, 2, 1] [3, 2, 1]

Kiedy używać generatora

Generator nie zawsze jest ogólnie szybszy. Jeśli ostatecznie użyjesz każdej wartości, całkowita praca będzie podobna, a zrozumienie listy może być nawet szybsze w przypadku małych danych, ponieważ wiąże się z mniejszym obciążeniem na element. Główne korzyści to wykorzystanie pamięci i szybsze uzyskiwanie pierwszych wyników.

Typowe błędy

Ponowne wykorzystanie wyczerpanego generatora

To dopada prawie każdego w pewnym momencie. Generator pamięta, że jest skończony:

g = count_up(2)
print(list(g), list(g))

# [1, 2] []

Drugie wywołanie otrzymuje pustą listę bez żadnego błędu. Wywołaj funkcję ponownie, aby uzyskać nowy generator, lub użyj podejścia klasowego pokazanego powyżej.

Oczekiwanie na natychmiastowe uruchomienie kodu

def noisy():
    print("body runs")
    yield 1

n = noisy()        # nothing is printed
print(next(n))     # body runs, then 1

Sprawdzanie argumentów na górze generatora nie jest uruchamiane aż do pierwszego next(), więc błędy mogą pojawić się daleko od wywołania, które je spowodowało.

Inne pułapki

• Wywołanie len() lub indeksowanie. Generatory nie obsługują żadnego z nich i zgłaszają TypeError.
• Zbyt szybkie zamknięcie pliku. Zwrócenie generatora z wnętrza bloku with może oznaczać zamknięcie pliku przed odczytaniem jakiejkolwiek linii. Umieść yield wewnątrz bloku with.
• Zawijanie wszystkiego w list(). To eliminuje korzyści związane z pamięcią.
• Używanie jednej do małych danych. Zwykła lista jest często jaśniejsza.

Podsumowanie

Generator to funkcja, która może się zatrzymać. Ten jeden pomysł zapewnia niskie zużycie pamięci, nieskończone sekwencje i czyste potoki. Aby zastosować to w praktyce, znajdź w kodzie miejsce, które tworzy dużą listę tylko po to, aby raz ją zapętlić i zamień ją w generator. Następnie spróbuj połączyć ze sobą dwa małe generatory w prawdziwym pliku dziennika.

Najczęstsze pytania

Ucz się dalej