⭐ Python Developer · Chặng 5Bài 2/5Bài học~75 phút

Iterator và generator trong Python: yield, itertools, file lớn

Hiểu iterator đằng sau vòng for, viết generator với yield, generator expression, xử lý file lớn từng dòng và các hàm itertools.

Iterator và generator trong Python: yield, itertools, file lớn

Học xong bài này, bạn sẽ

  • Hiểu giao thức iterator đằng sau vòng for
  • Viết generator bằng yield và generator expression
  • Xử lý file lớn theo dòng, dùng itertools

Nên học trước: Comprehension, unpacking và hàm dựng sẵn

Nội dung bài viết
  1. 1. Điều gì xảy ra trong vòng for
  2. 2. Generator: hàm có yield
  3. 3. Vì sao generator tiết kiệm bộ nhớ
  4. 4. Xử lý file lớn bằng pipeline generator
  5. 5. yield from và generator vô hạn
  6. 6. itertools: hộp đồ nghề cho iterator
  7. Tóm tắt
  8. Bài tập

Đọc file log 5 GB bằng f.read() là cách nhanh nhất để máy treo. Python có một cơ chế xử lý dữ liệu "từng phần tử một", không bao giờ nạp tất cả vào bộ nhớ: iterator và generator. Hiểu chúng, bạn sẽ hiểu điều gì thực sự xảy ra sau mỗi vòng for, và viết được pipeline xử lý dữ liệu lớn chỉ với vài dòng.

1. Điều gì xảy ra trong vòng for

ds = ["a", "b", "c"]
it = iter(ds)              # lấy iterator từ một iterable
print(next(it))            # lấy phần tử kế tiếp
print(next(it), next(it))
try:
    next(it)
except StopIteration:
    print("Hết phần tử")
a
b c
Hết phần tử

Vòng for x in ds thực chất làm đúng như trên: gọi iter(ds), rồi gọi next() liên tục cho đến khi gặp StopIteration thì dừng. Hai khái niệm:

  • Iterable: thứ duyệt được (list, str, dict, file, range...), có __iter__.
  • Iterator: con trỏ đang duyệt, có __next__, nhớ mình đang ở đâu và chỉ đi một chiều, dùng một lần.
so = map(int, ["1", "2", "3"])      # map, filter, zip trả về iterator
print(sum(so))
print(sum(so))                      # lần hai: đã cạn!
6
0

Đây là lỗi kinh điển: duyệt một iterator hai lần thì lần hai rỗng. Cần dùng nhiều lần thì chuyển thành list: so = list(map(...)).

2. Generator: hàm có yield

Tự viết iterator bằng class với __iter__, __next__ khá dài. Generator là cách ngắn gọn: một hàm có từ khóa yield.

def dem_nguoc(n):
    print("Bắt đầu")
    while n > 0:
        yield n                # trả n ra ngoài và TẠM DỪNG tại đây
        n -= 1                 # lần next() sau chạy tiếp từ dòng này
    print("Kết thúc")


gen = dem_nguoc(3)             # chưa chạy dòng nào!
print(type(gen).__name__)
for x in gen:
    print(x)
generator
Bắt đầu
3
2
1
Kết thúc

Gọi hàm generator không chạy thân hàm mà trả về một đối tượng generator. Mỗi lần next(), hàm chạy tới yield kế tiếp, trả giá trị và "đóng băng" mọi biến cục bộ, chờ lần gọi sau. Khi hàm chạy hết, StopIteration được ném tự động.

3. Vì sao generator tiết kiệm bộ nhớ

import sys

ds = [x * x for x in range(1_000_000)]
gen = (x * x for x in range(1_000_000))
print(f"list: {sys.getsizeof(ds) / 1e6:.1f} MB, generator: {sys.getsizeof(gen)} byte")
print(sum(ds) == sum(gen))
list: 8.4 MB, generator: 208 byte
True

(Số byte chính xác khác nhau đôi chút giữa các phiên bản Python; kết quả trên chạy bằng Python 3.14.) List giữ cả triệu phần tử cùng lúc (con số 8,4 MB mới chỉ là mảng con trỏ, chưa tính các số nguyên). Generator chỉ giữ trạng thái hiện tại, dù sinh ra một tỉ phần tử. Đổi lại, generator không có len(), không truy cập gen[5], không duyệt lại được.

4. Xử lý file lớn bằng pipeline generator

from pathlib import Path

Path("truy_cap.log").write_text(
    "# log máy chủ\n"
    "2026-10-29 08:01 GET /trang-chu 200 120ms\n"
    "2026-10-29 08:02 GET /api/don-hang 500 2300ms\n"
    "\n"
    "2026-10-29 08:03 POST /api/don-hang 201 340ms\n"
    "2026-10-29 08:05 GET /api/don-hang 500 2100ms\n",
    encoding="utf-8",
)


def doc_dong(p):
    with open(p, encoding="utf-8") as f:
        for dong in f:
            dong = dong.strip()
            if dong and not dong.startswith("#"):
                yield dong


def phan_tich(cac_dong):
    for dong in cac_dong:
        ngay, gio, phuong_thuc, duong_dan, ma, thoi_gian = dong.split()
        yield {"duong_dan": duong_dan, "ma": int(ma), "ms": int(thoi_gian.removesuffix("ms"))}


def chi_loi(ban_ghi):
    return (b for b in ban_ghi if b["ma"] >= 500)


loi = list(chi_loi(phan_tich(doc_dong("truy_cap.log"))))
print(len(loi), max(b["ms"] for b in loi), loi[0]["duong_dan"])
2 2300 /api/don-hang

Ba bước nối nhau như đường ống: đọc dòng → tách trường → lọc lỗi. Mỗi bước nhận một iterable và trả về generator, nên tại bất kỳ thời điểm nào chỉ có một dòng đi qua đường ống. File 5 GB hay 5 KB, bộ nhớ dùng gần như như nhau. Mỗi bước là một hàm nhỏ, dễ hiểu, dễ thử riêng.

5. yield from và generator vô hạn

from pathlib import Path


def ma_don_hang(tien_to="DH", bat_dau=1):
    n = bat_dau
    while True:                     # vô hạn: chỉ an toàn vì người dùng lấy có giới hạn
        yield f"{tien_to}{n:05d}"
        n += 1


gen = ma_don_hang()
print([next(gen) for _ in range(3)])


def moi_dong(cac_file):
    for p in cac_file:
        yield from Path(p).read_text(encoding="utf-8").splitlines()   # chuyển tiếp từng phần tử


Path("a.txt").write_text("a1\na2", encoding="utf-8")
Path("b.txt").write_text("b1", encoding="utf-8")
print(list(moi_dong(["a.txt", "b.txt"])))
['DH00001', 'DH00002', 'DH00003']
['a1', 'a2', 'b1']

6. itertools: hộp đồ nghề cho iterator

import itertools as it

print(list(it.islice(it.count(10, 5), 4)))            # lấy 4 phần tử đầu của dãy vô hạn
print(list(it.chain([1, 2], (3, 4), "ab")))            # nối nhiều iterable
print(list(it.batched(range(7), 3)))                    # chia lô (Python 3.12+)
print(list(it.pairwise([10, 13, 11, 18])))              # cặp liên tiếp (3.10+)
print(list(it.accumulate([100, -30, 50])))              # cộng dồn
print(list(it.product("AB", [1, 2])))                   # tích Descartes
print(list(it.combinations(["An", "Bình", "Chi"], 2)))  # tổ hợp chập 2

don = sorted([("Hà Nội", 3), ("Huế", 1), ("Hà Nội", 2)], key=lambda d: d[0])
for tp, nhom in it.groupby(don, key=lambda d: d[0]):    # cần sắp theo khóa trước!
    print(tp, sum(sl for _, sl in nhom))
[10, 15, 20, 25]
[1, 2, 3, 4, 'a', 'b']
[(0, 1, 2), (3, 4, 5), (6,)]
[(10, 13), (13, 11), (11, 18)]
[100, 70, 120]
[('A', 1), ('A', 2), ('B', 1), ('B', 2)]
[('An', 'Bình'), ('An', 'Chi'), ('Bình', 'Chi')]
Huế 1
Hà Nội 5

Thứ tự in Huế trước Hà Nội vì so sánh chuỗi theo mã Unicode: chữ "u" (U+0075) đứng trước "à" (U+00E0). groupby chỉ gom các phần tử liền kề có cùng khóa, nên luôn sắp xếp theo khóa đó trước.

Tóm tắt

  • for = iter() + next() đến StopIteration; iterator chỉ dùng một lần.
  • Hàm có yield là generator: chạy lười, tạm dừng ở mỗi yield, tốn rất ít bộ nhớ.
  • Xử lý file lớn: pipeline các generator nhỏ nối nhau.
  • yield from chuyển tiếp; itertools: islice, chain, batched, pairwise, groupby...

Bài tập

Bài 1. Đọc dòng hợp lệ

Viết generator doc_dong_hop_le(duong_dan) trả từng dòng đã bỏ khoảng trắng hai đầu, bỏ qua dòng trống và dòng bắt đầu bằng #, kèm số dòng gốc.

Xem đáp án
from pathlib import Path


def doc_dong_hop_le(duong_dan):
    with open(duong_dan, encoding="utf-8") as f:
        for so_dong, dong in enumerate(f, start=1):
            dong = dong.strip()
            if dong and not dong.startswith("#"):
                yield so_dong, dong


Path("cau_hinh.txt").write_text("# cấu hình\nhost=localhost\n\n  port=8000  \n#debug=1\n", encoding="utf-8")
for so, noi_dung in doc_dong_hop_le("cau_hinh.txt"):
    print(so, noi_dung)
2 host=localhost
4 port=8000

Giữ số dòng gốc giúp báo lỗi chính xác ("dòng 4 sai định dạng") khi xử lý tiếp.

Bài 2. Xử lý theo lô

Chia 10.000 bản ghi thành các lô 500 để "gửi" (giả lập bằng cách đếm), in số lô và kích thước lô cuối. Làm hai cách: itertools.batched (3.12+) và islice (mọi phiên bản).

Xem đáp án
import itertools as it

ban_ghi = ({"id": i} for i in range(10_000))          # generator: giả lập nguồn dữ liệu lớn
lo = list(it.batched(ban_ghi, 500))
print(len(lo), len(lo[-1]))


def chia_lo(iterable, kich_thuoc):
    nguon = iter(iterable)
    while lo := list(it.islice(nguon, kich_thuoc)):
        yield lo


print(sum(1 for _ in chia_lo(range(10_250), 500)), len(list(chia_lo(range(10_250), 500))[-1]))
20 500
21 250

Gửi theo lô là kỹ thuật chuẩn khi ghi vào CSDL hay gọi API: mỗi lần gửi 500 bản ghi nhanh hơn rất nhiều so với 10.000 lần gửi lẻ, mà không phải giữ cả 10.000 bản ghi trong bộ nhớ. Ở ví dụ đầu, list(...) bên ngoài chỉ để đếm cho dễ thấy; khi dùng thật, duyệt for lo in it.batched(...) và xử lý từng lô.

Nguồn tham khảo: Python Tutorial: Iterators, Generators; Functional Programming HOWTO; itertools.

Bài tập thực hành

  1. Viết generator doc_dong_hop_le(duong_dan) bỏ dòng trống và dòng bắt đầu bằng #.
  2. Dùng itertools.batched hoặc islice chia 10.000 bản ghi thành lô 500 để xử lý.

Làm xong bài tập mới chuyển sang bài tiếp theo: tự viết code là cách duy nhất để nhớ lâu.

Bài tiếp theo
Ban biên tập HocFree

Chúng tôi viết những bài hướng dẫn dễ hiểu, thực tế để ai cũng có thể tự học lập trình và AI, hoàn toàn miễn phí.