Hãy tưởng tượng tải một tệp nhật ký 10 GB vào danh sách chỉ để tìm lỗi. Chương trình của bạn có thể hết bộ nhớ trước khi tìm thấy. Trình tạo Python giải quyết vấn đề đó bằng cách tạo ra từng giá trị theo yêu cầu, để bạn có thể xử lý dữ liệu khổng lồ hoặc thậm chí vô tận mà hầu như không có bộ nhớ.

Hướng dẫn này trình bày từng bước những gì thực sự xảy ra khi máy phát điện chạy. Chúng tôi đã chạy từng ví dụ trên Python 3.13 và kết quả đầu ra là từ lần chạy đó. Sẽ giúp bạn dễ dàng làm quen với các hàm và vòng lặp mà Hướng dẫn Python dành cho người mới bắt đầu của chúng tôi đề cập đến.

Máy phát điện là gì?

Trình tạo là một loại trình vòng lặp đặc biệt mà bạn tạo bằng cách viết hàm bằng yield. Bất kỳ hàm nào có yield trong đó sẽ tự động trở thành hàm tạo và việc gọi nó sẽ cung cấp cho bạn một đối tượng trình tạo thay vì chạy mã.

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...>

Lưu ý rằng “bắt đầu” không được in. Việc gọi hàm chỉ tạo ra trình tạo. Chưa có gì bên trong chạy cả.

Năng suất hoạt động như thế nào, từng bước một

Mỗi lệnh gọi tới next() sẽ chạy hàm cho đến khi đạt đến yield, trả lại giá trị đó và cố định tại chỗ. Cuộc gọi tiếp theo sẽ tiếp tục ngay sau dòng đó, với mọi biến cục bộ còn nguyên.

print(next(gen))
# starting
# 1

print(next(gen))
# 2

next(gen)
# finished
# StopIteration

Theo dõi đầu ra một cách cẩn thận. “bắt đầu” chỉ xuất hiện ở next() đầu tiên. Ở lần thứ hai, việc thực thi tiếp tục từ nơi nó dừng, vì vậy n vẫn khả dụng và trở thành 2. Ở lần thứ ba, vòng lặp kết thúc, in “hoàn thành”, hàm rơi ra khỏi điểm cuối và Python tăng StopIteration để báo hiệu rằng không còn gì.

Bạn hiếm khi gọi next() cho mình. Vòng lặp for thực hiện việc đó cho bạn và xử lý StopIteration một cách lặng lẽ, cũng như list(), sum() và các chức năng tương tự:

print(list(count_up(3)))

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

năng suất so với lợi nhuận

Sự chậm trễ này được gọi là đánh giá lười biếng: các giá trị chỉ được xử lý khi cần thiết. Một đơn giản return bên trong trình tạo chỉ đơn giản là kết thúc nó, kích hoạt StopIteration.

Sự khác biệt về bộ nhớ, được đo

Chúng tôi đã so sánh danh sách một triệu ô vuông với một trình tạo tương đương, sử dụng 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

Cấu trúc riêng của danh sách chiếm khoảng 8,4 MB, trong khi trình tạo chỉ chiếm 200 byte trên hệ thống của chúng tôi. Khoảng cách thực sự thậm chí còn lớn hơn, vì getsizeof không tính các đối tượng nguyên bên trong danh sách. Kích thước của trình tạo cũng giữ nguyên cho một tỷ mục vì nó chỉ lưu trữ trạng thái hiện tại chứ không lưu trữ kết quả.

Tuy nhiên, có một sự đánh đổi. Một danh sách có thể được sử dụng lại, lập chỉ mục và đo lường bằng len(). Một máy phát điện không cung cấp những thứ này. Nếu bạn cần truy cập ngẫu nhiên hoặc bạn sẽ lặp lại nhiều lần trên một lượng nhỏ dữ liệu thì danh sách sẽ đơn giản hơn. Xem hướng dẫn của chúng tôi về Danh sách Python so với bộ dữ liệu so với tập hợp để biết thêm về các loại đó.

biểu thức trình tạo

Đối với những trường hợp đơn giản, bạn không cần hàm. Biểu thức trình tạo trông giống như danh sách hiểu với dấu ngoặc tròn thay cho dấu ngoặc vuông:

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

Khi biểu thức trình tạo là đối số duy nhất cho hàm, như trong sum(), bạn có thể bỏ qua các dấu ngoặc phụ. Đây là một thói quen gọn gàng để tính tổng trên dữ liệu lớn vì không có danh sách tạm thời nào được tạo.

Xây dựng đường dẫn dữ liệu

Đây là nơi máy phát điện thực sự tỏa sáng. Các máy phát điện nhỏ có thể được xâu chuỗi để mỗi mục đi qua từng bước, từng bước một:

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']

Mỗi bước thực hiện một công việc nhỏ và có thể tự kiểm tra. Trong sử dụng thực tế, hãy hoán đổi danh sách mẫu lấy một tệp đang mở, vì các đối tượng tệp có thể được đọc từng dòng, như hướng dẫn của chúng tôi về xử lý tệp Python trình bày. Ngay cả một bản ghi nhiều gigabyte sau đó cũng sẽ được xử lý với rất ít bộ nhớ.

Chuỗi vô hạn

Một danh sách không thể là vô hạn, nhưng một trình tạo thì có thể, bởi vì nó chỉ tính giá trị tiếp theo. Sử dụng itertools.islice để lấy bao nhiêu tùy ý:

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]

Tuy nhiên, hãy cẩn thận: việc gọi list(fibonacci()) không giới hạn sẽ chạy cho đến khi hết bộ nhớ. Mẫu tương tự phù hợp với trình tạo ID, vòng bỏ phiếu và kết quả API được phân trang, trong đó bạn chỉ tìm nạp trang tiếp theo khi trang hiện tại hết.

sản lượng từ và lô

yield from chuyển sang một vòng lặp khác, giúp bạn tiết kiệm được một vòng lặp lồng nhau:

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

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

# [1, 2, 3, 4]

Một mẫu rất thực tế là chia dữ liệu thành các lô có kích thước cố định, chẳng hạn như để chèn một nghìn hàng vào cơ sở dữ liệu cùng một lúc:

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]]

if batch cuối cùng đảm bảo rằng nhóm còn sót lại nhỏ hơn không bị mất. Python 3.12 trở lên cũng bao gồm itertools.batched, thực hiện công việc tương tự.

gửi, đóng và dọn dẹp

Máy phát điện cũng có thể nhận được giá trị. send() tiếp tục trình tạo và giá trị trở thành kết quả của biểu thức yield. Bạn phải gọi next() lần đầu tiên để đạt được yield đầu tiên:

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

Hầu hết mọi người hiếm khi cần điều này. Một mối quan tâm phổ biến hơn là dọn dẹp. Nếu bạn dừng sớm, khối finally vẫn chạy khi đóng trình tạo:

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

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

# cleanup ran

Pytest sử dụng chính ý tưởng này: một thiết bị cố định với yield sẽ tiến hành dọn dẹp sau đó, như hướng dẫn pytest của chúng tôi minh họa. Tương tự như vậy, trình trang trí contextmanager của thư viện chuẩn sẽ biến trình tạo thành khối with.

Máy phát điện trong lớp học

Viết một phương thức __iter__ làm trình tạo là cách dễ nhất để làm cho lớp của riêng bạn có thể lặp lại được. Một phần thưởng là mỗi vòng lặp có một trình tạo mới, do đó đối tượng có thể được lặp đi lặp lại:

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]

Khi nào nên sử dụng máy phát điện

Nhìn chung, máy phát điện không phải lúc nào cũng nhanh hơn. Nếu bạn sử dụng mọi giá trị thì tổng công việc sẽ tương tự và việc hiểu danh sách thậm chí có thể nhanh hơn đối với dữ liệu nhỏ vì nó tốn ít chi phí hơn cho mỗi mục. Lợi ích chính là sử dụng bộ nhớ và nhận được kết quả đầu tiên sớm hơn.

Những lỗi thường gặp

Tái sử dụng máy phát điện đã cạn kiệt

Điều này thu hút gần như tất cả mọi người tại một số điểm. Một máy phát điện nhớ rằng nó đã hoàn thành:

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

# [1, 2] []

Cuộc gọi thứ hai nhận được một danh sách trống không có lỗi nào cả. Gọi lại hàm để có trình tạo mới hoặc sử dụng cách tiếp cận lớp được trình bày ở trên.

Mong đợi mã sẽ chạy ngay lập tức

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

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

Việc kiểm tra đối số ở đầu trình tạo không chạy cho đến next() đầu tiên, do đó, lỗi có thể xuất hiện khác xa với lệnh gọi gây ra chúng.

Các bẫy khác

• Gọi len() hoặc lập chỉ mục. Trình tạo không hỗ trợ và tăng TypeError.
• Đóng tệp quá sớm. Việc trả lại trình tạo từ bên trong khối with có thể có nghĩa là tệp sẽ đóng trước khi bất kỳ dòng nào được đọc. Đặt yield bên trong khối with.
• Gói mọi thứ trong list(). Điều đó sẽ làm mất đi lợi ích về bộ nhớ.
• Sử dụng một danh sách cho dữ liệu nhỏ. Danh sách đơn giản thường rõ ràng hơn.

Lời kết

Trình tạo là một chức năng có thể tạm dừng. Ý tưởng đó mang lại cho bạn mức sử dụng bộ nhớ thấp, trình tự vô tận và đường ống sạch sẽ. Để áp dụng nó vào thực tế, hãy tìm một vị trí trong mã của bạn để xây dựng một danh sách lớn chỉ để lặp lại nó một lần và biến nó thành một trình tạo. Sau đó thử nối hai trình tạo nhỏ lại với nhau trên một tệp nhật ký thực.

Câu hỏi thường gặp

Tiếp tục học hỏi