Iterator & generator

Vòng for trông đơn giản, nhưng bên dưới là một giao thức: Python gọi iter() để lấy một iterator, rồi gọi next() liên tục tới khi gặp StopIteration. Bấm qua từng bước:

• ▸for x in ds ≡ it = iter(ds); rồi lặp x = next(it) tới khi StopIteration.
• ▸Bạn không thấy StopIteration vì for tự bắt nó để dừng.
• ▸Hiểu giao thức này = bạn TỰ tạo được thứ “for được”.

Iterable = lặp được (có __iter__); iterator = giữ vị trí (có __next__):

class DemNguoc:
    def __init__(self, n):
        self.n = n
    def __iter__(self):          # tra ve mot iterator (chinh no)
        return self
    def __next__(self):          # tra phan tu ke tiep
        if self.n <= 0:
            raise StopIteration  # het -> bao dung
        self.n -= 1
        return self.n + 1

for x in DemNguoc(3):
    print(x)

3
2
1

• ▸__iter__ trả về iterator; __next__ trả phần tử kế, hết thì raise StopIteration.
• ▸Một iterator dùng XONG là cạn - phải tạo mới để lặp lại.
• ▸Cách này dài dòng → generator (Bước 3) làm gọn hơn nhiều.

Hàm có yield là một generator. Gọi nó KHÔNG chạy thân hàm; mỗi next() chạy tới yield kế rồi tạm dừng, giữ nguyên trạng thái:

def dem_nguoc(n):
    while n > 0:
        yield n          # tra ra n roi TAM DUNG tai day
        n -= 1

for x in dem_nguoc(3):
    print(x)

3
2
1

• ▸Gọi dem_nguoc(3) chỉ TẠO generator - chưa chạy gì (lười).
• ▸yield = trả một giá trị rồi tạm dừng; next() sau chạy tiếp từ chỗ đó.
• ▸Generator tự lo __iter__/__next__/StopIteration cho bạn.

Vì generator chỉ sinh từng phần tử khi cần, nó xử lý được dữ liệu lớn hay vô hạn mà không dựng tất cả trong RAM:

# List comprehension: DUNG ca 1 trieu phan tu trong bo nho
tong1 = sum([x * x for x in range(1_000_000)])

# Generator expression: LUOI, chi giu mot phan tu tai mot thoi diem
tong2 = sum(x * x for x in range(1_000_000))

print(tong1 == tong2)

True

• ▸[ ... ] = list (eager, tốn bộ nhớ); ( ... ) = generator (lazy).
• ▸Đưa thẳng vào hàm: sum(x*x for x in ds) - khỏi ngoặc trong, không dựng list trung gian.
• ▸Hợp đọc file lớn, luồng dữ liệu, dãy vô hạn - giữ ít trong RAM.

Generator không chỉ cho ra giá trị - nó còn nhận vào. send(v) chạy tiếp và biến v thành kết quả của yield đang dừng (đây là nền của coroutine):

import inspect

def averager():
    total = 0; n = 0; avg = None
    while True:
        x = yield avg        # GUI x vao day; tra avg ra ngoai
        total += x; n += 1
        avg = total / n

g = averager()
print(inspect.getgeneratorstate(g))   # GEN_CREATED
next(g)                                # "moi" toi yield dau tien
print(g.send(10))                      # 10.0
print(g.send(20))                      # 15.0  ((10+20)/2)
g.close()
print(inspect.getgeneratorstate(g))   # GEN_CLOSED

GEN_CREATED
10.0
15.0
GEN_CLOSED

def chain(*its):
    for it in its:
        yield from it        # chuyen tiep moi gia tri cua it ra ngoai

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

[1, 2, 3, 4]

• ▸send(v): vừa lấy ra vừa GỬI v vào (v = kết quả của yield). Phải next() “mồi” trước.
• ▸close() dừng generator (trạng thái GEN_CLOSED); inspect.getgeneratorstate xem trạng thái.
• ▸yield from delegate sang generator/iterable con - gọn & chuyển tiếp cả send.

Nhiều generator nối nhau thành một đường ống xử lý lười; module itertools cho sẵn nhiều mảnh ghép:

import itertools

def doc_so(ds):
    for s in ds:
        yield int(s)

def chi_chan(nums):
    for n in nums:
        if n % 2 == 0:
            yield n

duong_ong = chi_chan(doc_so(["1", "2", "3", "4", "5", "6"]))
print(list(itertools.islice(duong_ong, 2)))   # chi lay 2 phan tu dau

[2, 4]

• ▸Mỗi tầng generator chỉ lấy phần tử khi tầng sau yêu cầu - lười suốt đường ống.
• ▸itertools: count (đếm vô hạn), islice (cắt), chain (nối), takewhile/groupby… đều trả iterator.
• ▸Đường ống generator = xử lý dữ liệu lớn theo dòng, ít bộ nhớ.