Praktyczny test

licznik = Licznik(1, 4)

for n in licznik:
    print(n)

# Wynik:
# 1
# 2
# 3

Nasz obiekt Licznik zachowuje się jak wbudowana funkcja range().

Wszystko na raz?

Jeśli stworzysz listę miliona liczb, Python musi natychmiast zarezerwować dla nich miejsce w pamięci RAM.

lista = [x for x in range(1000000)]
# RAM: UUUUUUUUUUUUUUUUUUGH! 30-40 MB zajęte od razu.

A co jeśli potrzebujesz tych liczb tylko po kolei? Czy musimy je wszystkie trzymać w pamięci jednocześnie? Tutaj wchodzą generatory.

Magiczne słowo yield

Generator to prosty i elegancki sposób na tworzenie iteratora przy użyciu funkcji.

Różnica między normalną funkcją a generatorem:

• return: Zwraca wartość i kończy (niszczy) funkcję.
• yield: Zwraca wartość, ale **pauzuje** funkcję, zapamiętując wszystkie jej zmienne i pozycję.

Przy następnym wywołaniu, funkcja startuje dokładnie tam, gdzie skończyła!

Funkcja, która pauzuje

def moj_generator():
    print("Start")
    yield 1
    print("Krok 2")
    yield 2
    print("Koniec")

gen = moj_generator()
print(next(gen))
# Wypisze: Start, potem 1
print(next(gen))
# Wypisze: Krok 2, potem 2

Lazy Evaluation

Generatory nie liczą niczego "na zapas". Produkują elementy tylko na wyraźne żądanie (np. przez next() lub pętlę for).

• Oszczędność czasu: Nie czekasz na wygenerowanie miliarda elementów, zanim zaczniesz przetwarzać pierwszy.
• Oszczędność pamięci: Pamięć zajmuje tylko aktualnie przetwarzany element.

Wieczna pętla bez crashu

def parzyste_bez_konca():
    liczb = 0
    while True:
        yield liczb
        liczb += 2

gen = parzyste_bez_konca()
print(next(gen)) # 0
print(next(gen)) # 2
# ... i tak do końca świata (lub wyłączenia prądu)

Mimo while True, program nie zawiesza się, bo yield oddaje kontrolę do reszty kodu.

Kiedy wybrać co?

Generatory w pigułce

Podobnie jak "List Comprehensions", mamy wyrażenia generujące. Różnią się tylko nawiasami:

# List Comprehension (tworzy listę w pamięci)
kwadraty_lista = [x*x for x in range(10)]

# Generator Expression (tworzy iterator)
kwadraty_gen = (x*x for x in range(10))

Jeśli potrzebujemy danych tylko raz do pętli lub sumowania, nawiasy okrągłe są zawsze lepszym wyborem.

Przykład z życia

Wyobraź sobie plik logi_serwera.txt o rozmiarze 20 GB. Chcesz znaleźć tylko linie z błędem "ERROR".

Złe podejście: lines = open().readlines() - komputer padnie (brak RAM).

Dobre podejście: Użycie iteratora pliku (Python domyślnie czyta plik liniami jako generator).

Efektywne filtrowanie

def szukaj_bledow(sciezka):
    with open(sciezka) as plik:
        for linia in plik:
            if "ERROR" in linia:
                yield linia.strip()

# Zużycie RAM: stałe i minimalne, niezależnie od rozmiaru pliku
for blad in szukaj_bledow("serwer.log"):
    print(blad)

Komunikacja dwustronna

Generatory mogą nie tylko wysyłać dane, ale też je odbierać w trakcie pracy!

def akumulator():
    suma = 0
    while True:
        liczba = yield suma
        if liczba is None: break
        suma += liczba

a = akumulator()
next(a) # Uruchamiamy generator
print(a.send(10)) # Wysyłamy 10, odbieramy sumę 10
print(a.send(20)) # Wysyłamy 20, odbieramy sumę 30

Przekazywanie pałeczki

W Pythonie 3.3+ słowo yield from pozwala jednemu generatorowi delegować pracę do innego (lub dowolnego iteratora).

def polacz_ciagi():
    yield from range(3)
    yield from ["A", "B"]

# Wynik: 0, 1, 2, "A", "B"

Usprawnia to budowanie hierarchicznych procesorów danych i czytelność kodu.

Gotowe klocki

Biblioteka itertools zawiera dziesiątki zoptymalizowanych funkcji do pracy na iteratorach.

• cycle(): Powtarza sekwencję w nieskończoność.
• chain(): Łączy kilka iteratorów w jeden.
• islice(): Wycinanie fragmentów z generatora (bez tworzenia listy).
• combinations(): Tworzy kombinacje elementów.

RAM przy 10 milionach liczb

Spróbujmy zmierzyć różnicę:

1. [x for x in range(10**7)]: ok. 400 MB RAM.
2. (x for x in range(10**7)): ok. 128 bajtów RAM.

Różnica jest kolosalna. W profesjonalnych systemach, gdzie przetwarza się logi, transakcje giełdowe czy dane pogodowe, generatory to jedyny sposób na stabilność.

Jak Python to robi?

Kiedy funkcja generatora jest pauzowana przez yield, Python zachowuje jej "ramkę stosu" (stack frame). To jak zrobienie zdjęcia (snapshot) całego stanu pamięci funkcji.

• Lokalne zmienne trwają.
• Instrukcja jest zatrzymana "na linii".
• Kolejne next() po prostu wznawia wykonanie.

Generator jest jednorazowy

Wielu początkujących próbuje przeiterować po generatorze dwa razy:

gen = (x for x in range(3))
for a in gen: print(a) # Działa: 0, 1, 2
for b in gen: print(b) # Nic się nie wypisze! Generator jest pusty.

Jeśli potrzebujesz tych samych danych dwa razy, musisz stworzyć nowy obiekt generatora lub (jeśli dane są małe) zamienić go na listę: lista = list(gen).

Integracja z obiektowością

Twoje klasy biznesowe (np. Magazyn, Druzyna) mogą stać się iterowalne. Wystarczy dodać im metodę __iter__.

class Druzyna:
    def __init__(self):
        self.zawodnicy = []
    
    def __iter__(self):
        # Zwracamy generator zamiast budować iterator od zera!
        for z in self.zawodnicy:
            yield z

Manualne sterowanie

Funkcja next() przyjmuje opcjonalny drugi argument: wartość domyślną. Zapobiega to rzuceniu błędu StopIteration.

gen = (x for x in range(1))
print(next(gen)) # 0
print(next(gen, "Koniec!")) # Zamiast błędu: Koniec!

To bardzo przydatne przy szukaniu pierwszego elementu spełniającego warunek w strumieniu danych.

Składanie procesów

Możemy łączyć generatory w łańcuchy. Dane płyną przez nie jak w rurach.

liczby = range(100)
kwadraty = (x*x for x in liczby)
parzyste_kwadraty = (x for x in kwadraty if x % 2 == 0)

# Nic jeszcze nie zostało policzone!
# Liczenie zacznie się dopiero tutaj:
print(next(parzyste_kwadraty))

Dlaczego to nie jest Error?

W Pythonie wyjątki są częścią normalnego sterowania programem (tzw. EAFP - Easier to Ask Forgiveness than Permission - łatwiej prosić o przebaczenie niż pozwolenie).

StopIteration to nie jest błąd krytyczny, to tylko sygnał: "Hej, praca skończona, możesz iść do domu". Pętla for "łapie" ten sygnał i po cichu kończy działanie.

Wstęp do asynchroniczności

Generatory były fundamentem nowoczesnego asyncio w Pythonie. Możliwość wstrzymania i wznowienia funkcji pozwala na "udawanie" wielu zadań naraz bez użycia ciężkich wątków.

Nazywa się to **kooperatywną wielozadaniowością** – zadanie "oddaje" procesor, gdy na coś czeka.

Przeciwwskazania

• Gdy musisz wielokrotnie wracać do tych samych danych (np. sortowanie).
• Gdy musisz skakać po indeksach (losowy dostęp).
• Gdy dane są bardzo małe – narzut na tworzenie generatora może być większy niż zysk.
• Gdy chcesz modyfikować elementy w trakcie (generatory są "tylko do odczytu").

Zamykanie zasobów

Dzięki temu, że generator pauzuje, możemy bezpiecznie używać w nim try...finally. Blok finally wykona się, nawet jeśli zamkniemy generator manualnie przez .close().

def czytnik():
    try:
        yield "Dane"
    finally:
        print("Zamykam połączenie!")

Najpopularniejsze iteratory

Te wbudowane funkcje to w rzeczywistości fabryki iteratorów:

# enumerate: (indeks, wartość)
for i, v in enumerate(["A", "B"]): ...

# zip: paruje elementy z dwóch list
for x, y in zip([1, 2], [3, 4]): ...

Nigdy nie tworzą one list tymczasowych, działają leniwie element po elemencie.

Przeszukiwanie folderów

Idealne do chodzenia po drzewach katalogów lub strukturach typu XML/JSON.

import os

def pokaz_pliki(sciezka):
    for p in os.listdir(sciezka):
        pelna = os.path.join(sciezka, p)
        if os.path.isdir(pelna):
            yield from pokaz_pliki(pelna)
        else:
            yield pelna

Czysty kod

• Funkcje będące generatorami nazywaj czasownikami (np. generuj_raport, pobierz_dane).
• Iteratory to zazwyczaj rzeczowniki (np. czytnik, emiter).
• Sygnalizuj, że funkcja jest generatorem w dokumentacji (docstring).

Relacje między klasami

W projektowaniu systemów Iterable i Iterator to często oddzielne klasy:

• Klasa Kolekcja posiada metodę getIterator().
• Klasa MojaKolekcjaIterator implementuje mechanizm chodzenia po Kolekcji.

W Pythonie często (choć nie zawsze) upraszczamy to do jednej klasy lub generatora.

Najważniejsze punkty

• Iterable ma __iter__ i pozwala zacząć pętlę.
• Iterator ma __next__ i zna aktualny element.
• Generator to funkcja z yield, która pauzuje stan.
• Leniwość (Lazy) to oszczędność pamięci i czasu.
• StopIteration to naturalny koniec taśmociągu danych.

Trening czyni mistrza

Napisz generator, który będzie zwracał kolejne liczby Fibonacciego do zadanej granicy.

Podpowiedź: Pamiętaj o dwóch początkowych liczbach (0 i 1) i sumowaniu ich w pętli while.

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

Koniec Wykładu 8

Dzisiaj nauczyliśmy się, jak Python radzi sobie z dużymi zbiorami danych. Umiejętność korzystania z iteratorów i generatorów odróżnia początkującego programistę od specjalisty (Seniora), który dba o zasoby systemu.

Dziękuję za uwagę!