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.
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
Đọ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()đếnStopIteration; iterator chỉ dùng một lần.- Hàm có
yieldlà generator: chạy lười, tạm dừng ở mỗiyield, tốn rất ít bộ nhớ. - Xử lý file lớn: pipeline các generator nhỏ nối nhau.
yield fromchuyể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
- Viết generator doc_dong_hop_le(duong_dan) bỏ dòng trống và dòng bắt đầu bằng #.
- 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.


