👋 Chào mừng đến với Nocoem — kiến thức Backend, System Design và lập trình. Khám phá ngay

Hiểu về Bytecode trong Python: Cách Python Thực Thi Mã Nguồn

Khám phá Python bytecode là gì, các Python sử dụng bytecode để thực thi mã của bạn, và làm thế nào hiểu biết điều này có thể giúp ích cho bạn
Hiểu về Bytecode trong Python
Hiểu về Bytecode trong Python: Cách Python Thực Thi Mã Nguồn
TL;DR: Python không chạy thẳng mã nguồn của bạn. Nó biên dịch file .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.

Mã nguồn (.py) Lexer (tokenize)tách thành token Parser ASTcây cú pháp trừu tượng Compiler Bytecode (.pyc)chỉ thị cho máy ảo Python VM (eval loop)thực thi, ra kết quả
Kiến trúc CPython: bốn bước lexer -> parser -> AST -> compiler là giai đoạn biên dịch (tạo ra bytecode); Python VM lo phần thực thi.

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:

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

1) LOAD_FAST a 2) LOAD_FAST b 3) BINARY_OP (+) a a b a+b
Ngăn xếp tính toán khi chạy 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
Lưu ý: Bytecode phụ thuộc phiên bản Python. Ví dụ trên đúng với Python ≤ 3.10; từ 3.11 nhiều opcode đã đổi (ví dụ 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:

  1. LOAD_GLOBAL 0 (print) - nạp hàm print từ không gian toàn cục (global namespace) lên ngăn xếp.
  2. LOAD_CONST 1 ('Hello, World!') - nạp hằng chuỗi "Hello, World!" lên ngăn xếp.
  3. CALL_FUNCTION 1 - gọi print với 1 đối số (chuỗi vừa nạp).
  4. POP_TOP - bỏ giá trị trả về của print khỏi stack (vì print() trả về None).
  5. LOAD_CONST 0 (None) - nạp None (giá trị trả về mặc định của hàm).
  6. RETURN_VALUE - trả None về 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
3 0 RESUME 0 4 2 LOAD_GLOBAL 1 (NULL + print) 14 LOAD_CONST 1 ('Hello, World!') 16 PRECALL 1 20 CALL 1 30 POP_TOP 32 LOAD_CONST 0 (None) 34 RETURN_VALUE

Đâ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?

  1. 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.
  2. 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.
  3. 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))
Hiệu năng (Python 3.11, số cụ thể tuỳ máy): dict() method: 0.0959 Literal {} method: 0.0809

Bạn sẽ thấy:

  • Bytecode khác nhau: cách dùng dict() phải nạp và gọi hàm dict (thêm LOAD_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, dict là 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))
Hiệu năng (Python 3.11, số cụ thể tuỳ máy): List comprehension: 0.183 list(range()): 0.061

Đ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.
Đừng suy diễn sai: ví dụ trên KHÔNG có nghĩa "list comprehension luôn chậm hơn". Nó chỉ thua khi bạn sao chép nguyên một iterable có sẵn (như 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.
Nhưng đừng lạm dụng: phần lớn thời gian, hãy ưu tiên mã dễ đọc, dễ bảo trì. Chỉ soi bytecode để tối ưu khi bạn thật sự có vấn đề về hiệu năng và đã đo đạc cẩn thận.

Nguồn tham khảo

- Kai

Thấy bài viết hữu ích?

0 lượt thích

Đăng nhận xét