Bản chất: bytecode & máy ảo CPython

Ở bài Làm quen Python ta biết Python biên dịch sang bytecode rồi máy ảo chạy. Giờ ta nhìn tận mắt bytecode đó bằng module chuẩn dis:

import dis
dis.dis("kq = a + b * c")

  0           RESUME                   0

  1           LOAD_NAME                0 (a)
              LOAD_NAME                1 (b)
              LOAD_NAME                2 (c)
              BINARY_OP                5 (*)
              BINARY_OP                0 (+)
              STORE_NAME               3 (kq)
              LOAD_CONST               0 (None)
              RETURN_VALUE

• ▸dis.dis(...) in ra bytecode CPython sinh ra - thấy đúng những gì Python thực sự làm, khỏi đoán.
• ▸RESUME ở đầu và LOAD_CONST None + RETURN_VALUE ở cuối là khung mặc định của mỗi module.
• ▸Sáu lệnh giữa chính là biểu thức kq = a + b * c của ta.

Máy ảo CPython là một stack machine (máy ảo dùng stack - ngăn xếp): LOAD_* đẩy một giá trị lên đỉnh; BINARY_OP / COMPARE_OP lấy vài giá trị xuống, tính, rồi đẩy kết quả; STORE_NAME lấy đỉnh ra cất vào biến. Bấm Tiếp → để xem stack đổi theo từng lệnh:

• ▸LOAD_NAME a: đẩy giá trị của a lên đỉnh stack.
• ▸BINARY_OP (+): lấy 2 số trên đỉnh, cộng, đẩy tổng lại.
• ▸STORE_NAME kq: lấy đỉnh ra, lưu vào biến kq.

Vì sao a + b * c tính nhân trước? Vì trình biên dịch sắp lệnh theo ưu tiên: nó đặt BINARY_OP * trước BINARY_OP +. Đổi sang (a + b) * c thì thứ tự hai lệnh đảo lại - và kết quả đổi từ 14 thành 20 (chọn hai tab đầu ở công cụ trên để so sánh):

• ▸Thứ tự các BINARY_OP trên stack CHÍNH LÀ thứ tự tính toán.
• ▸a + b * c → nhân (*) trước → 14; (a + b) * c → cộng (+) trước → 20.
• ▸Dấu ngoặc không còn tồn tại lúc chạy - nó đã đổi BYTECODE ngay từ lúc biên dịch.

Ai “chạy” chuỗi bytecode? Một vòng lặp eval viết bằng C (trong ceval.c của CPython): nó đọc từng bytecode và thực thi trên stack, lặp tới hết. Bytecode được lưu sẵn trong .pyc để khỏi dịch lại:

hello.py  (mã nguồn)
   │  biên dịch (compile)
   ▼
bytecode  ──lưu──▶  __pycache__/hello.cpython-314.pyc
   │  vòng lặp eval (ceval.c, viết bằng C)
   ▼  đọc & chạy từng lệnh trên STACK
kết quả

Soi bytecode cho thấy CPython làm sẵn nhiều thứ. Ba ví dụ (chạy thử dis trên máy bạn):

import dis
dis.dis("x = 2 + 3")

  LOAD_SMALL_INT     5        <- da tinh san 2 + 3 = 5 luc BIEN DICH!
  STORE_NAME         0 (x)
  LOAD_CONST         1 (None)
  RETURN_VALUE

def cong(a, b):
    return a + b
dis.dis(cong)

  RESUME
  LOAD_FAST_BORROW_LOAD_FAST_BORROW   (a, b)   <- bien CUC BO: tra theo VI TRI
  BINARY_OP                           (+)
  RETURN_VALUE

• ▸Gấp hằng số: 2 + 3 được tính SẴN lúc biên dịch → không có BINARY_OP, chỉ nạp 5.
• ▸Biến cục bộ trong hàm dùng họ LOAD_FAST (tra theo VỊ TRÍ) - nhanh hơn LOAD_NAME (tra theo TÊN ở module).
• ▸So sánh (a > b) sinh COMPARE_OP: lấy 2 giá trị, đẩy True/False lên stack.

• ▸Gỡ lỗi khó: thấy Python THẬT SỰ làm gì, không phải đoán.
• ▸Hiểu hiệu năng: vì sao một cách viết sinh ít/nhiều lệnh hơn.
• ▸Hiểu các tối ưu của CPython - nền cho khoá nâng cao.