__iter__/__next__), vòng for ... in, và nhất là yield (generator). Nên phần lớn thời gian bạn không phải tự viết class iterator, Python làm hộ.Bạn viết for x in something mỗi ngày. Nhưng đã bao giờ bạn tự hỏi: vì sao cùng một vòng for lại duyệt được list, tuple, dict, string, cả file lẫn range, dù cách chúng lưu dữ liệu khác nhau hoàn toàn? Câu trả lời là một design pattern nằm sẵn trong lõi ngôn ngữ: Iterator. Bài này tôi sẽ mổ xẻ nó, và cho bạn thấy vì sao trong Python bạn hiếm khi phải viết nó bằng tay.
Iterator là gì?
Iterator là mẫu tách việc duyệt ra khỏi cấu trúc dữ liệu. Tập hợp chỉ việc chứa dữ liệu; một đối tượng riêng lo việc đi qua từng phần tử. Người dùng gọi kiểu "cho tôi phần tử tiếp theo" mà không cần biết dữ liệu nằm ở đâu hay xếp thế nào.
Hình dung bạn đến xem một cuốn album ảnh ở nhà người quen. Bạn không tự lục xem ảnh được cất trong ngăn kéo, hộp thiếc hay đĩa cứng. Bạn chỉ ngồi đó, và người chủ nhà lật từng trang cho bạn xem: trang này, trang kế, trang kế nữa, đến hết thì dừng. Bạn xem được toàn bộ ảnh mà chẳng cần biết chúng được lưu ra sao. Người lật album đó chính là iterator.
Iterable và iterator: hai thứ khác nhau
Đây là chỗ nhiều người nhầm, cần tách bạch ngay:
- Iterable (thứ duyệt được): đối tượng biết cách tạo ra một iterator. Trong Python, nó có method
__iter__. Ví dụ: list, tuple, dict, string. Chính là cuốn album. - Iterator (thứ đi duyệt): đối tượng giữ vị trí hiện tại và biết phần tử kế tiếp là gì. Trong Python, nó có method
__next__(và cũng có__iter__trả về chính nó). Chính là người lật album.
Nói cách khác: iterable là nguồn, iterator là con trỏ chạy trên nguồn đó. Một iterable có thể sinh ra nhiều iterator độc lập (nhiều người cùng lật một cuốn album, mỗi người ở một trang). Còn iterator thì dùng một lần: lật hết là hết, muốn xem lại phải xin iterator mới.
Vấn đề: duyệt mà không lộ cấu trúc
Giả sử bạn có một tập hợp và muốn cho người khác duyệt qua nó. Cách ngây thơ là để họ thò tay vào ruột:
# Cach te: bat nguoi dung biet ben trong la mot list, va tu quan ly chi so
i = 0
while i < len(playlist._bai): # phai biet co thuoc tinh _bai, va no la list
print(playlist._bai[i])
i += 1
Đoạn này hỏng ở hai điểm. Thứ nhất, người dùng phải biết bên trong là một list và tên thuộc tính là _bai. Ngày mai bạn đổi sang cây hay danh sách liên kết, mọi nơi duyệt như trên đều vỡ. Thứ hai, logic duyệt (quản lý chỉ số, kiểm tra hết chưa) bị nhân bản khắp nơi. Iterator giải quyết cả hai: giấu cấu trúc bên trong, và gom logic duyệt vào một chỗ. Người dùng chỉ cần một hợp đồng chung: "cho tôi phần tử kế tiếp, hết thì báo".
Cách làm trong Python
Python chuẩn hoá hợp đồng này thành giao thức iterator (iterator protocol): một iterable có __iter__, một iterator có __next__ và báo hết bằng cách raise StopIteration. Vòng for, list(), iter(), next() đều nói chuyện qua đúng hợp đồng này.
Cách 1: tự viết iterator bằng class
Để thấy rõ cơ chế, ta viết đầy đủ: một collection Playlist (iterable) trả về một PlaylistIterator (iterator) riêng biệt.
class Playlist: # iterable: biet cach tao ra iterator
def __init__(self, bai):
self._bai = bai
def __iter__(self): # moi lan goi tra ve mot iterator MOI
return PlaylistIterator(self._bai)
class PlaylistIterator: # iterator: giu vi tri, biet phan tu ke tiep
def __init__(self, bai):
self._bai = bai
self._i = 0
def __iter__(self):
return self
def __next__(self):
if self._i >= len(self._bai):
raise StopIteration # het phan tu thi bao hieu dung
item = self._bai[self._i]
self._i += 1
return item
pl = Playlist(["Song A", "Song B", "Song C"])
for ten in pl: # for goi __iter__ roi __next__ lien tuc
print(ten)
it = iter(pl) # iter() = goi __iter__
print(next(it), "/", next(it)) # next() = goi __next__
Chú ý: vòng for ten in pl thực chất làm đúng những gì bạn thấy ở hai dòng cuối, nhưng tự động. Nó gọi iter(pl) một lần để lấy iterator, rồi gọi next() liên tục cho tới khi gặp StopIteration thì dừng êm. Người viết vòng for không cần biết Playlist chứa dữ liệu bằng list hay bằng gì khác, đó chính là "không lộ cấu trúc".
Cách 2: dùng generator với yield (gọn hơn nhiều)
Viết cả một class iterator như trên khá dài dòng. Python có yield: chỉ cần một hàm có yield, Python tự biến nó thành generator, và generator đã là một iterator hoàn chỉnh (tự có __next__, tự nhớ vị trí, tự raise StopIteration khi hàm kết thúc). Bạn không phải viết gì thêm.
Sức mạnh thật sự lộ ra khi cấu trúc phức tạp. Duyệt một cây nhị phân theo thứ tự giữa (in-order) mà viết bằng class iterator thì rất rối vì phải tự quản lý ngăn xếp. Với yield thì tự nhiên như mô tả bằng lời:
class Node:
def __init__(self, val, trai=None, phai=None):
self.val, self.trai, self.phai = val, trai, phai
def duyet(node): # generator: yield tra ve tung phan tu
if node is None:
return
yield from duyet(node.trai) # duyet cay con trai
yield node.val # tra ve gia tri node hien tai
yield from duyet(node.phai) # duyet cay con phai
cay = Node(4, Node(2, Node(1), Node(3)), Node(6, Node(5), Node(7)))
for v in duyet(cay): # duyet in-order ma khong lo cau truc cay
print(v, end=" ")
print()
print(list(duyet(cay)))
Hàm duyet chỉ mô tả thứ tự đi (trái, rồi node, rồi phải) và yield ra từng giá trị. Toàn bộ chuyện nhớ đang ở đâu, đi tiếp thế nào, khi nào dừng là Python lo. Người gọi vẫn chỉ thấy một chuỗi phần tử tuần tự, không hề biết phía sau là một cái cây. Đúng tinh thần Iterator: duyệt qua một hợp đồng chung, giấu sạch cấu trúc.
Một điểm cộng nữa: generator sinh phần tử lười (lazy), tính tới đâu trả tới đó chứ không dựng sẵn cả danh sách trong bộ nhớ. Nhờ vậy bạn duyệt được cả nguồn dữ liệu rất lớn hoặc vô hạn (đọc file dòng theo dòng, kéo trang dữ liệu từ API...) mà không sợ tràn bộ nhớ.
for của Python chạy trên giao thức iterator, và generator là cách hiện thực gọn nhất của giao thức đó. Dù vậy, xét theo nghĩa GoF thì generator chưa phủ hết mọi khía cạnh của mẫu này. Generator chỉ đi một chiều và dùng một lần: hết là hết, muốn duyệt lại phải tạo cái mới. Nó cũng không có khái niệm nhiều con trỏ duyệt song song trên cùng một collection một cách tường minh, và không hỗ trợ sẵn các thao tác như lùi lại, nhảy tới một vị trí, hay đọc trạng thái duyệt hiện tại. Khi bạn cần đúng những thứ đó, một lớp iterator tường minh vẫn có chỗ đứng.Khi nào dùng, và khi nào Python đã làm hộ
Iterator hữu ích khi: bạn muốn cho phép duyệt một tập hợp mà không phơi ra cấu trúc bên trong; bạn có nhiều cách duyệt khác nhau trên cùng dữ liệu (xuôi, ngược, theo tầng...); hoặc dữ liệu quá lớn/vô hạn nên cần sinh dần thay vì dựng hết một lúc.
__iter__/__next__ khi chưa cần. Trong Python:
- Nếu dữ liệu đã nằm trong list/tuple/dict, chúng vốn đã là iterable, cứ
forthẳng. - Nếu cần một cách duyệt riêng, gần như luôn dùng generator (
yield) thay vì class iterator, nó ngắn hơn và ít lỗi hơn nhiều. - Chỉ viết class iterator đầy đủ khi bạn thật sự cần một đối tượng iterator có trạng thái phức tạp hoặc nhiều method phụ, một trường hợp hiếm.
Trong hệ thống thật
Ở backend, Iterator hiếm khi xuất hiện dưới dạng một class tên là SomethingIterator. Nó nấp sau những chỗ này:
- Duyệt kết quả phân trang của API. Người dùng thư viện chỉ thấy một vòng
forchạy qua từng bản ghi; bên trong, iterator tự gọi trang tiếp theo khi dữ liệu của trang hiện tại đã hết. Chuyện offset, cursor hay token trang sau bị giấu hoàn toàn. - Đọc file lớn hoặc log theo dòng. Một file log vài GB vẫn duyệt được bằng
for dong in fmà không nạp hết vào bộ nhớ, vì bản thân đối tượng file đã là một iterator. - Con trỏ (cursor) kết quả truy vấn cơ sở dữ liệu. Driver lấy kết quả theo lô rồi trả ra từng dòng, nên một bảng mười triệu dòng vẫn duyệt được với lượng bộ nhớ gần như không đổi.
- Duyệt đối tượng trong bucket lưu trữ. Danh sách object của một bucket luôn trả về theo trang; SDK bọc lại thành một chuỗi duyệt được liền mạch.
- Duyệt cây thư mục bằng
os.scandirhoặcpathlib.Path.rglob: bạn nhận từng entry một thay vì một danh sách dựng sẵn của cả cây (và cây thư mục cũng chính là ví dụ kinh điển của Composite). - Đọc luồng dữ liệu từ hàng đợi. Consumer thường được viết như một vòng lặp trên iterator: có message thì trả ra, chưa có thì chờ.
Với backend, giá trị lớn nhất của Iterator không phải là code trông đẹp hơn, mà là hai thứ rất thực tế: duyệt được tập dữ liệu lớn hơn bộ nhớ, và giấu đi chuyện phân trang để chỗ gọi không phải lặp lại câu hỏi "còn trang nữa không".
Trade-off
Được:
- Tiết kiệm bộ nhớ, vì dữ liệu chỉ được lấy theo nhu cầu: xử lý xong phần tử nào thì bỏ phần tử đó.
- Client dùng cùng một cú pháp cho mọi nguồn dữ liệu: list trong bộ nhớ, file trên đĩa hay API ở xa đều chỉ là một vòng
for. - Giấu được chi tiết phân trang hay nguồn ở xa, nên đổi cách lấy dữ liệu không làm vỡ chỗ gọi.
- Ghép chuỗi xử lý bằng generator rất gọn: lọc, biến đổi, cắt bớt nối vào nhau mà vẫn chỉ đi qua dữ liệu một lượt.
- Dừng sớm rất rẻ: đủ kết quả thì
break, phần dữ liệu còn lại không bao giờ bị lấy về.
Phải trả giá:
- Duyệt lười khiến lỗi xuất hiện muộn: lúc gọi hàm thì im ru, đến giữa vòng lặp mới nổ.
- Khó debug, vì giá trị chỉ tồn tại khi chạy tới nơi; in một generator ra chỉ thấy đúng một dòng mô tả object.
- Một lần duyệt là hết, nên vô tình duyệt lại cùng một iterator sẽ ra rỗng mà chẳng báo lỗi gì.
- Mỗi lần lấy lô mới có thể là một lần gọi mạng ẩn: một vòng
fortrông vô hại có thể là hàng trăm request.
Tóm tắt
- Iterator cho phép duyệt tuần tự một tập hợp mà không lộ cấu trúc bên trong, bằng cách tách logic duyệt ra khỏi dữ liệu.
- Iterable là thứ tạo ra iterator (
__iter__); iterator là thứ giữ vị trí và trả phần tử kế tiếp (__next__, hết thìStopIteration). Vòngfornói chuyện qua đúng hợp đồng này. - Trong Python, cách gọn nhất để tự làm iterator là generator với
yield: tự nhớ vị trí, tự dừng, lại còn sinh phần tử lười (lazy). - Đừng viết class iterator thủ công khi list hoặc generator đã đủ. Đây là pattern Python làm hộ bạn gần hết.
- Kai