| Hiểu về Bytecode trong Python: Cách Python Thực Thi Mã Nguồn |
.py thành bytecode - một danh sách chỉ thị nhỏ, đơn giản - rồi đưa cho máy ảo Python (PVM) thực thi từng bước trên một ngăn xếp (stack). Hiểu bytecode giúp bạn lý giải vì sao cách viết này nhanh hơn cách viết kia, và dùng module dis để "nhìn xuyên" vào code của mình.Nhiều người nói "Python là ngôn ngữ thông dịch". Đúng một nửa thôi. Trong bài này tôi sẽ chỉ cho bạn thấy bước trung gian ít ai để ý - bytecode - và cách nó quyết định tốc độ code của bạn.
Python là ngôn ngữ biên dịch hay thông dịch?
Thực ra là cả hai. Python có một bước biên dịch trung gian: mã nguồn được chuyển thành tập chỉ thị dành cho một máy ảo (virtual machine), sau đó máy ảo này mới lần lượt thực thi các chỉ thị đó.
Hãy hình dung: mã nguồn .py giống công thức nấu ăn viết cho người đọc. Python dịch nó thành một danh sách thao tác nhỏ, rành mạch (bytecode) để một "đầu bếp máy" (máy ảo) làm theo từng bước - không cần suy diễn gì thêm.
Bytecode là gì?
Các file .pyc bạn thấy trong thư mục __pycache__ không chỉ là bản "nén" của mã nguồn. Chúng chứa các chỉ thị bytecode đã biên dịch sẵn để máy ảo Python thực thi - nhờ đó lần chạy sau không phải biên dịch lại từ đầu.
Máy ảo Python hoạt động thế nào?
(Bài này nói về CPython - bản Python phổ biến nhất; các bản khác như PyPy dùng cơ chế khác, có JIT.) CPython là một máy ảo dựa trên ngăn xếp (stack-based virtual machine). Mỗi lời gọi hàm tạo ra một "khung" (frame) làm việc với hai ngăn xếp (stack) chính:
- Ngăn xếp lời gọi hàm (Call Stack): chồng các frame của những hàm đang chạy; đáy là điểm bắt đầu chương trình.
- Ngăn xếp tính toán (Evaluation Stack): nơi thực thi thực sự - hầu hết opcode chỉ là đẩy (push), thao tác, rồi lấy (pop) phần tử ra khỏi ngăn xếp.
Ngày xưa CPython còn có thêm một ngăn xếp khối (block stack) để quản lý vòng lặp và try/except. Nhưng khối vòng lặp đã bị bỏ từ Python 3.8, và từ 3.11 khối ngoại lệ được thay bằng bảng ngoại lệ (co_exceptiontable, cơ chế "zero-cost exceptions") - nên frame hiện đại về cơ bản chỉ còn hai ngăn xếp trên.
a + b: nạp a, nạp b (b nằm trên đỉnh), rồi BINARY_OP lấy 2 giá trị xuống và đẩy a+b lên.Ví dụ thực tế
Hãy xem một hàm đơn giản:
def hello():
print("Hello, World!")
Khi biên dịch, đoạn mã này chuyển thành các chỉ thị bytecode như sau:
2 0 LOAD_GLOBAL 0 (print)
2 LOAD_CONST 1 ('Hello, World!')
4 CALL_FUNCTION 1
6 POP_TOP
8 LOAD_CONST 0 (None)
10 RETURN_VALUE
CALL_FUNCTION -> CALL). Vì vậy đừng học thuộc từng opcode - hãy nắm ý tưởng: nạp lên stack, gọi, lấy kết quả.Các bước diễn ra:
LOAD_GLOBAL 0 (print)- nạp hàmprinttừ không gian toàn cục (global namespace) lên ngăn xếp.LOAD_CONST 1 ('Hello, World!')- nạp hằng chuỗi"Hello, World!"lên ngăn xếp.CALL_FUNCTION 1- gọiprintvới 1 đối số (chuỗi vừa nạp).POP_TOP- bỏ giá trị trả về củaprintkhỏi stack (vìprint()trả vềNone).LOAD_CONST 0 (None)- nạpNone(giá trị trả về mặc định của hàm).RETURN_VALUE- trảNonevề cho nơi gọi.
Công cụ hữu ích: module dis
Để tự xem bytecode của bất kỳ hàm nào, dùng module dis có sẵn trong Python:
import sys, dis
print(sys.version) # biết phiên bản Python để hiểu vì sao opcode có thể khác
dis.dis(hello) # hiển thị bytecode của hàm hello
Đây là kết quả thật chạy trên Python 3.11. So với listing Python 3.10 phía trên: 3.11 thêm RESUME, PRECALL, và CALL_FUNCTION đã đổi thành CALL. Cùng một hàm nhưng bytecode khác nhau tuỳ phiên bản, đó là lý do đừng học thuộc từng opcode.
Mẹo: luôn chạy print(sys.version) trước khi so bytecode. Ví dụ trong bài chụp ở Python 3.10; nếu bạn dùng 3.12 hay 3.13, tên opcode gần như chắc chắn sẽ khác.
Tại sao nên quan tâm đến bytecode?
- Hiểu rõ mô hình thực thi: dự đoán chính xác điều gì xảy ra khi code chạy, hỗ trợ tối ưu hiệu năng.
- Giải đáp câu hỏi hiệu năng: vì sao cách viết này nhanh hơn cách viết kia.
- Mở rộng kiến thức: làm quen với lập trình dựa trên ngăn xếp (stack-oriented programming).
Ví dụ 1: So sánh cách tạo dict
Cùng tạo một từ điển theo hai cách và soi bytecode của chúng:
import dis
import timeit
# Phương thức 1: Sử dụng dict()
def create_dict_method1():
return dict(a=1, b=2, c=3)
# Phương thức 2: Sử dụng literal {}
def create_dict_method2():
return {'a': 1, 'b': 2, 'c': 3}
# In bytecode để so sánh
print("Bytecode cho dict():")
dis.dis(create_dict_method1)
print("\nBytecode cho literal {}:")
dis.dis(create_dict_method2)
# So sánh hiệu năng
print("\nHiệu năng:")
print("dict() method:", timeit.timeit(create_dict_method1, number=1000000))
print("Literal {} method:", timeit.timeit(create_dict_method2, number=1000000))
Bạn sẽ thấy:
- Bytecode khác nhau: cách dùng
dict()phải nạp và gọi hàmdict(thêmLOAD_GLOBAL+CALL), trong khi literal{}dựng dict trực tiếp bằng một chỉ thị chuyên dụng - ít thao tác hơn. - Hiệu năng: literal
{}nhanh hơn một chút (trên Python 3.11 ở máy mình: ~0.081s so với ~0.096s, tức nhanh hơn khoảng 15-20%; các bản Python cũ thường chênh nhiều hơn). Lý do chính: ít thao tác trong bytecode và không tốn một lời gọi hàm - thêm nữa,dictlà tên toàn cục có thể bị ghi đè nên không thể "hằng số hoá".
Ví dụ 2: So sánh cách tạo list
import dis
import timeit
# Phương thức 1: Sử dụng range() với list comprehension
def method1():
return [x for x in range(1000)]
# Phương thức 2: Sử dụng list() với range()
def method2():
return list(range(1000))
# In bytecode
print("Bytecode cho list comprehension:")
dis.dis(method1)
print("\nBytecode cho list():")
dis.dis(method2)
# So sánh hiệu năng
print("\nHiệu năng:")
print("List comprehension:", timeit.timeit(method1, number=10000))
print("list(range()):", timeit.timeit(method2, number=10000))
Điều thú vị: ở đây list(range(1000)) nhanh hơn khoảng 3 lần list comprehension (0.061s so với 0.183s ở phép đo trên), dù comprehension trông "Pythonic" hơn. Vì list(range()) dựng list ở tầng C trong một bước, còn comprehension phải lặp ở tầng Python. Bài học:
- Không phải cú pháp ngắn gọn nào cũng nhanh nhất.
- Nhưng lưu ý điều kiện: mẹo thay bằng
list(range())chỉ đúng khi bạn sao chép nguyên range. Nếu cần biến đổi/lọc phần tử (vd[f(x) for x in range(n)]) thì comprehension mới là lựa chọn. - Bytecode giúp bạn thấy rõ "chi phí" của từng cách viết.
- Chọn cách nào còn tuỳ ngữ cảnh - nhưng giờ bạn có công cụ để tự kiểm chứng.
list(range(n))). Khi cần biến đổi hoặc lọc phần tử - ví dụ [x*2 for x in range(n)] hay [x for x in data if x > 0] - thì list comprehension thường là cách vừa nhanh vừa rõ ràng nhất, và gần như luôn tốt hơn vòng lặp for kèm .append().Kết luận
Hiểu bytecode mang lại cho bạn ba thứ:
- Tối ưu hiệu năng có cơ sở: nhận diện thao tác thừa, chọn cách triển khai nhanh hơn - thay vì đoán mò.
- Debug sâu hơn: hiểu chính xác chuyện gì xảy ra khi code chạy.
- Nắm chắc Python: hiểu cơ chế bên dưới, không chỉ cú pháp.
Nguồn tham khảo
- Python docs - dis - Disassembler for Python bytecode (tài liệu chính thức của module
disvà danh sách opcode). - CPython devguide - Exception Handling (giải thích "zero-cost exceptions" &
co_exceptiontablethay cho block stack từ 3.11). - Inside the Python Virtual Machine (Obi Ike-Nwosu) - sách online miễn phí, chuyên sâu về trình thông dịch Python.
- A Python Interpreter Written in Python (Allison Kaptur) - tự xây một trình thông dịch Python đơn giản bằng Python.
- Mã nguồn CPython - đọc
Python/ceval.cđể xem vòng lặp thực thi bytecode.
- Kai