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

Những góc khuất thú vị về Python mà Developer thường bỏ qua

Những góc khuất thú vị về Python mà Developer thường bỏ qua
Những góc khuất thú vị về Python mà Developer thường bỏ qua
Những góc khuất thú vị về Python mà Developer thường bỏ qua
TL;DR: Python nhìn thì "dễ", nhưng bên dưới lớp cú pháp gọn gàng là cả một cỗ máy: mọi thứ đều là object, biến chỉ là cái nhãn dán lên object, thread bị khoá thông dịch toàn cục (GIL) trói, class có thể do metaclass "đẻ" ra, và việc truy cập thuộc tính đi qua descriptor. Hiểu 15 góc khuất này giúp bạn tối ưu bộ nhớ, gỡ lỗi nhanh và đọc code người khác đỡ hoang mang.

Tôi hay đùa rằng Python là một ngôn ngữ "dễ học, khó thạo". Cú pháp thân thiện tới mức bạn viết được chương trình đầu tiên trong vài phút, nhưng chính sự thân thiện đó lại giấu đi rất nhiều cơ chế bên dưới. Đến một ngày bạn gặp một con bug kiểu "sao list này tự nhiên bị thay đổi?", hoặc "sao đa luồng mà chẳng nhanh hơn?", và mọi thứ trở nên khó hiểu.

Trong bài này tôi sẽ dẫn bạn đi qua những góc khuất thú vị nhất của Python - những thứ mà ngay cả dev có kinh nghiệm cũng hay bỏ qua. Mỗi mục tôi kèm một ví dụ chạy được và một ví von đời thường để bạn nhớ lâu.

1. Bên dưới Python: CPython, VM và bytecode

Python là một đặc tả ngôn ngữ (language specification), còn thứ bạn cài về máy thường là CPython - bản hiện thực (implementation) tham chiếu viết bằng C. Khi chạy một file .py, CPython không dịch thẳng ra mã máy như C. Thay vào đó nó biên dịch mã nguồn thành bytecode (mã trung gian giữa mã nguồn Python và mã máy), rồi giao cho một máy ảo (virtual machine - VM) kiểu stack thực thi từng lệnh một.

  • Hiểu bytecode giúp bạn lý giải vì sao một đoạn code chạy nhanh/chậm, và các công cụ như PyPy (dùng JIT) hay CPython khác nhau ở đâu.
  • Bạn có thể "nhìn tận mắt" bytecode bằng module dis có sẵn.

Ví von: mã nguồn Python giống công thức nấu ăn viết bằng tiếng Việt. Bytecode là bản dịch sang một thứ "tiếng bếp" ngắn gọn, chuẩn hoá. VM là người đầu bếp đọc từng dòng "tiếng bếp" đó mà làm.

import dis

def add(a, b):
    return a + b

dis.dis(add)
Kết quả (rút gọn, có thể khác giữa các phiên bản Python):
  2           RESUME                   0
  3           LOAD_FAST                0 (a)
              LOAD_FAST                1 (b)
              BINARY_OP                0 (+)
              RETURN_VALUE

2. Python là "pass-by-object-reference"

Đây là chỗ gây hiểu lầm kinh điển. Python không truyền theo giá trị (pass-by-value) cũng không truyền theo địa chỉ biến (pass-by-reference) như C++. Nó truyền tham chiếu tới object (pass-by-object-reference, đôi khi gọi là "call by sharing").

  • Khi bạn đưa một biến vào hàm, hàm nhận được một cái nhãn mới trỏ tới cùng object.
  • Nếu object đó đổi được tại chỗ (mutable: list, dict, set), thay đổi bên trong hàm ảnh hưởng ra ngoài. Nếu object bất biến (immutable: int, str, tuple), bạn không thể sửa nó - chỉ có thể gán nhãn sang object khác.
def modify_list(lst):
    lst.append(4)   # lst trỏ cùng object với original -> ảnh hưởng ra ngoài
    lst = [7, 8, 9] # gán lại: lst giờ trỏ tới list MỚI, tách khỏi original
    lst.append(10)  # sửa list mới, không đụng tới original

original = [1, 2, 3]
modify_list(original)
print(original)
Kết quả
[1, 2, 3, 4]
Chỉ append(4) lọt ra ngoài, vì sau khi lst = [7,8,9] thì nhãn lst đã trỏ đi chỗ khác.

Ví von: hãy coi object như một căn nhà, còn biến là mảnh giấy ghi địa chỉ dán trên cửa. Truyền biến vào hàm là photo thêm một tờ giấy ghi cùng địa chỉ. Bạn sơn lại tường (mutate) thì ai cầm giấy tới cũng thấy nhà đổi màu. Nhưng nếu bạn viết đè một địa chỉ khác lên tờ giấy photo (gán lại), tờ giấy gốc vẫn trỏ về nhà cũ.

3. Mọi thứ trong Python đều là object

Số, chuỗi, hàm, class, module - tất cả đều là object. Kể cả type cũng là object. Điều này nghe hàn lâm nhưng lại là nền tảng cho rất nhiều "phép thuật" của Python: bạn gán được hàm cho biến, truyền hàm vào hàm khác (first-class function), gắn thuộc tính cho hàm, thậm chí tạo class ngay lúc chạy.

# Hàm là object: gán cho biến, có thuộc tính, cho vào list
def say_hello(name):
    return f"Hello {name}"

greet = say_hello
say_hello.custom_attr = "I'm an attribute"

for func in [len, sum, str.upper]:
    print(func.__name__)

# First-class function: truyền hàm làm tham số
def apply_operation(func, value):
    return func(value)

print(apply_operation(len, "hello"))

# Class là object của type -> tạo class động bằng type()
DynamicClass = type("DynamicClass", (), {
    "x": 1,
    "say_hi": lambda self: "Hi!",
})
obj = DynamicClass()
print(obj.x, obj.say_hi())

# Ngay cả type cũng là object
print(type(int), type(type))
Kết quả
len
sum
upper
5
1 Hi!
<class 'type'> <class 'type'>

Ví von: ở nhiều ngôn ngữ, hàm và class là "công dân hạng hai" - chỉ được gọi, không được cầm nắm. Trong Python, tất cả đều là "công dân hạng nhất", được đối xử bình đẳng: cái gì cũng nhét vào biến, list, hay tham số được.

4. Global Interpreter Lock (GIL)

Khoá thông dịch toàn cục (Global Interpreter Lock - GIL) là một khoá loại trừ (mutex) trong CPython, đảm bảo tại mỗi thời điểm chỉ một thread thực thi bytecode Python, kể cả khi máy bạn có nhiều nhân.

  • Vì thế tác vụ nặng CPU (CPU-bound) chạy đa luồng thường không nhanh hơn - các thread phải chờ nhau giành GIL.
  • Nhưng tác vụ nặng I/O (I/O-bound: đọc file, gọi mạng) thì đa luồng vẫn lợi, vì khi một thread chờ I/O nó nhả GIL cho thread khác chạy.
  • Muốn tận dụng nhiều nhân cho CPU-bound: dùng multiprocessing (mỗi tiến trình có GIL riêng) hoặc đẩy phần nặng xuống C.
Cập nhật: từ CPython 3.13 đã có bản free-threaded (không GIL) ở dạng thử nghiệm theo PEP 703. Đến CPython 3.14, bản free-threaded được nâng lên trạng thái hỗ trợ chính thức (không còn "thử nghiệm", nhưng vẫn là một build tuỳ chọn) theo PEP 779. Tức là GIL không còn là "định mệnh" vĩnh viễn của Python - nhưng ở bản build mặc định phổ biến hiện nay, nó vẫn còn đó.

Ví von: tưởng tượng một căn bếp đông đầu bếp nhưng chỉ có một con dao. Nhiều người đấy, nhưng ai muốn thái phải chờ tới lượt cầm dao (GIL). Nếu công việc là "thái rau" (CPU-bound) thì đông người vô nghĩa. Nhưng nếu công việc là "đứng chờ nồi sôi" (I/O-bound) thì trong lúc chờ, người ta nhả dao cho người khác thái - nên đông người lại nhanh.

import threading, time
from multiprocessing import Process

def cpu_heavy(n):
    for i in range(n):
        _ = i ** 2

def run_serial(task, *args):
    start = time.time()
    task(*args); task(*args)
    return time.time() - start

def run_threads(task, *args):
    start = time.time()
    t1 = threading.Thread(target=task, args=args)
    t2 = threading.Thread(target=task, args=args)
    t1.start(); t2.start(); t1.join(); t2.join()
    return time.time() - start

def io_heavy():
    time.sleep(1)  # giả lập chờ I/O

print(f"CPU serial : {run_serial(cpu_heavy, 10**7):.2f}s")
print(f"CPU threads: {run_threads(cpu_heavy, 10**7):.2f}s")  # GIL -> không nhanh hơn
print(f"I/O serial : {run_serial(io_heavy):.2f}s")           # ~2s
print(f"I/O threads: {run_threads(io_heavy):.2f}s")          # ~1s -> nhanh hơn
Kết quả (minh hoạ, tuỳ máy/phiên bản):
CPU serial : 0.73s
CPU threads: 0.74s
I/O serial : 2.02s
I/O threads: 1.00s
Đúng như dự đoán: đa luồng chỉ cứu được I/O-bound, không cứu được CPU-bound.

5. Name binding và namespace (quy tắc LEGB)

Khi bạn viết x = 10, Python không "đổ giá trị vào ô nhớ tên x". Nó gắn tên (name binding) x với một object. Khi tra cứu một tên, Python đi tìm theo thứ tự LEGB: Local (trong hàm) -> Enclosing (hàm bao ngoài) -> Global (cấp module) -> Built-in.

x = 10  # global

def outer():
    x = 20  # enclosing
    def inner():
        x = 30  # local
        print(f"Local x: {x}")
    inner()
    print(f"Enclosing x: {x}")

outer()
print(f"Global x: {x}")
Kết quả
Local x: 30
Enclosing x: 20
Global x: 10

Muốn sửa biến ở tầng ngoài, bạn phải khai báo rõ bằng global (cho tầng module) hoặc nonlocal (cho tầng enclosing):

x = 0
def modify_global():
    global x
    x += 1

def outer():
    y = 0
    def inner():
        nonlocal y
        y += 1
    inner()
    return y

Ví von: LEGB giống cách bạn tìm một cuốn sách: xem trên bàn mình trước (Local), không có thì ra kệ chung phòng (Enclosing), rồi tới thư viện toà nhà (Global), cuối cùng là thư viện quốc gia (Built-in). Tìm thấy ở đâu thì dừng ở đó.

6. Generator: không giữ cả dãy trong bộ nhớ

Generator sinh giá trị theo yêu cầu (lazy evaluation) - mỗi lần bạn hỏi mới tính một phần tử, thay vì dựng sẵn cả dãy. Nhờ vậy nó rất tiết kiệm bộ nhớ khi làm việc với dữ liệu lớn hoặc dãy vô hạn. Đổi [] thành () là bạn có generator expression.

# Generator function
def number_gen(n):
    i = 0
    while i < n:
        yield i
        i += 1

# Generator expression: không dựng sẵn 1 triệu phần tử trong RAM
squared = (x * x for x in range(1_000_000))

# Generator hai chiều với send()
def counter():
    i = 0
    while True:
        val = yield i        # nhận giá trị gửi từ ngoài vào
        i = val if val is not None else i + 1

c = counter()
print(next(c))     # khởi động generator -> 0
print(c.send(10))  # nhảy tới 10
print(next(c))     # 11
Kết quả
0
10
11

Ví von: list giống nấu sẵn cả nồi phở 100 tô rồi mới bưng ra - tốn chỗ, mà khách chưa chắc ăn hết. Generator giống quán làm tới đâu bưng tới đó: khách gọi tô nào mới làm tô đó.

7. Method Resolution Order (MRO)

Khi một class kế thừa nhiều class (đa kế thừa), Python cần luật để biết tìm phương thức ở đâu trước. Luật đó là thứ tự phân giải phương thức (Method Resolution Order - MRO), tính bằng thuật toán C3 linearization. Bạn xem MRO của một class qua ClassName.__mro__ hoặc ClassName.mro().

class A: pass
class B: pass
class C(A, B): pass
class D(B, A): pass
# class E(C, D): pass  # TypeError: MRO conflict (C muốn A trước B, D muốn B trước A)

print([cls.__name__ for cls in C.__mro__])
Kết quả
['C', 'A', 'B', 'object']

Ví von: MRO như thứ tự người bạn hỏi mượn tiền: hỏi mình trước (class con), rồi tới bố mẹ theo một trật tự cố định. Nếu hai nhánh gia đình cãi nhau về ai phải hỏi trước (như E(C, D) ở trên), Python từ chối tạo class luôn thay vì đoán bừa - đúng tinh thần "In the face of ambiguity, refuse the temptation to guess".

8. Garbage collection: đếm tham chiếu + gom vòng lặp

CPython dọn rác theo hai cơ chế. Cơ chế chính là đếm tham chiếu (reference counting): mỗi object đếm xem có bao nhiêu nhãn trỏ tới nó, về 0 là giải phóng ngay. Bổ trợ là bộ gom rác theo thế hệ (generational garbage collection) trong module gc, chuyên xử lý tham chiếu vòng (reference cycle) mà reference counting không tự phá được. Dùng weakref để tạo tham chiếu "yếu" không làm tăng bộ đếm, tránh rò rỉ bộ nhớ.

import weakref

# Tham chiếu vòng: a giữ b, b giữ a -> reference count không bao giờ về 0
class Node:
    def __init__(self):
        self.next = None

a = Node(); b = Node()
a.next = b
b.next = a

# Giải pháp: dùng weakref cho liên kết ngược
class BetterNode:
    def __init__(self):
        self._ref = None

    @property
    def ref(self):
        return self._ref() if self._ref else None

    @ref.setter
    def ref(self, node):
        self._ref = weakref.ref(node)  # tham chiếu yếu, không giữ object sống

Ví von: reference counting như bảng chấm công: hết người điểm danh vào phòng thì tắt điện. Nhưng nếu hai người "bảo lãnh" lẫn nhau (A ghi tên B, B ghi tên A) thì bảng không bao giờ về 0 - cần bác bảo vệ (gc) đi tuần phát hiện cái vòng đó mà dọn.

9. Context manager và câu lệnh with

Nhiều người tưởng with chỉ để đóng file. Thực ra đó là cơ chế quản lý tài nguyên tổng quát: bất cứ thứ gì cần "mở rồi phải nhớ đóng" (kết nối DB, khoá, đo thời gian) đều hợp. Bạn tự tạo context manager bằng cặp __enter__ / __exit__, hoặc gọn hơn với @contextmanager.

from contextlib import contextmanager
import time

class Timer:
    def __enter__(self):
        self.start = time.time()
        return self
    def __exit__(self, *args):
        print(f"Time taken: {time.time() - self.start:.4f}s")

@contextmanager
def timer():
    start = time.time()
    try:
        yield
    finally:
        print(f"Time taken: {time.time() - start:.4f}s")

with Timer():
    sum(range(1_000_000))

Ví von: with như thuê phòng khách sạn: __enter__ là nhận phòng, __exit__ là trả phòng. Dù bạn ở ngoan hay làm cháy cả phòng (ném exception), lúc rời đi lễ tân vẫn dọn dẹp - nhờ đặt phần dọn trong finally.

10. Decorator là higher-order function

Decorator là hàm nhận vào một hàm và trả về một hàm (khái quát hơn: một callable trả về callable). Nó cho bạn "bọc" thêm hành vi quanh hàm gốc mà không sửa ruột hàm đó. Bạn xếp chồng nhiều decorator, và một class có __call__ cũng làm decorator được.

import time
from functools import wraps

def timing(func):
    @wraps(func)  # giữ lại __name__, __doc__ của hàm gốc
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.time() - start:.4f}s")
        return result
    return wrapper

class CountCalls:
    def __init__(self, func):
        self.func = func
        self.count = 0
    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"Call #{self.count}")
        return self.func(*args, **kwargs)

@CountCalls
def say_hello():
    print("Hello!")

say_hello()
say_hello()
Kết quả
Call #1
Hello!
Call #2
Hello!
Cạm bẫy: nếu quên @wraps(func), hàm sau khi decorate sẽ mất __name__, __doc__ và chữ ký gốc - làm hỏng công cụ sinh docs và gây khó debug. Gần như lúc nào cũng nên thêm nó.

Ví von: decorator như lớp giấy gói quà. Món quà (hàm gốc) không đổi, nhưng bạn thêm được nơ, thiệp, lớp chống sốc (logging, đo giờ, đếm lượt) ở ngoài.

11. Duck typing và EAFP

Python không quan tâm object thuộc kiểu gì, chỉ quan tâm nó làm được gì - đó là duck typing: "nếu nó kêu quạc quạc và đi lạch bạch như vịt thì cứ coi là vịt". Kèm theo là phong cách EAFP (Easier to Ask for Forgiveness than Permission - cứ làm rồi bắt lỗi), thường sạch và nhanh hơn LBYL (Look Before You Leap - kiểm tra đủ điều kiện trước khi làm).

# LBYL: kiểm tra trước (dài dòng, dễ sót trường hợp)
if hasattr(obj, "run") and callable(obj.run):
    obj.run()

# EAFP: cứ làm, sai thì bắt (phong cách Python)
try:
    obj.run()
except AttributeError:
    pass  # xử lý khi thiếu method

# Duck typing: chỉ cần có quack() và walk(), không cần là "Duck"
class Duck:
    def quack(self): print("Quack!")
    def walk(self):  print("Walking like a duck!")

class Person:
    def quack(self): print("Imitation quack")
    def walk(self):  print("Walking like a human!")

def duck_test(thing):
    thing.quack()
    thing.walk()

duck_test(Duck())
duck_test(Person())  # vẫn chạy: chỉ cần đủ method cần thiết

Ví von: tuyển diễn viên đóng vai vịt cho phim. Bạn không xét giấy khai sinh (kiểu dữ liệu), chỉ cần ứng viên biết kêu quạc quạc và đi lạch bạch. Người hay vịt thật đều nhận vai được.

12. __slots__ tối ưu bộ nhớ

Mặc định mỗi instance giữ thuộc tính trong một __dict__ riêng - linh hoạt nhưng tốn RAM. Khai báo __slots__ để cố định trước danh sách thuộc tính: Python bỏ __dict__, lưu thuộc tính gọn hơn, truy cập nhanh hơn. Đổi lại, bạn mất khả năng gắn thuộc tính tuỳ ý lúc chạy.

class WithoutSlots:
    def __init__(self, x, y):
        self.x, self.y = x, y

class WithSlots:
    __slots__ = ("x", "y")
    def __init__(self, x, y):
        self.x, self.y = x, y

# Đo bộ nhớ chuẩn hơn bằng thư viện pympler (pip install pympler)
from pympler import asizeof
print("Without __slots__:", asizeof.asizeof(WithoutSlots(1, 2)), "bytes")
print("With    __slots__:", asizeof.asizeof(WithSlots(1, 2)), "bytes")

# w = WithSlots(1, 2); w.z = 3  # AttributeError: không có 'z' trong __slots__
Kết quả (minh hoạ, tuỳ máy/phiên bản - bản có __slots__ nhẹ hơn đáng kể):
Without __slots__: 152 bytes
With    __slots__: 56 bytes
Lưu ý: đừng dùng sys.getsizeof(obj) để so sánh - nó không cộng phần __dict__ đi kèm nên cho con số gây hiểu nhầm. Dùng pympler.asizeof để tính bộ nhớ sâu (kể cả object con) mới công bằng.

Ví von: __dict__ như một cái tủ có vô số ngăn kéo trống, muốn thêm gì cũng được nhưng cồng kềnh. __slots__ như hộp đựng đúc sẵn số ô cố định: nhẹ, gọn, nhưng không nhét thêm ô mới được.

13. Metaclass - "nhà máy" sản xuất class

Nếu class là khuôn để tạo object, thì metaclass là khuôn để tạo class. Metaclass mặc định của mọi class chính là type. Bằng cách viết metaclass riêng, bạn can thiệp vào lúc class được tạo ra: kiểm tra, chỉnh sửa, hay bổ sung thuộc tính cho nó.

class ValidationMeta(type):
    def __new__(cls, name, bases, attrs):
        for key, value in attrs.items():
            if key.startswith("__"):
                continue
            if not callable(value) and not isinstance(value, (int, str, float)):
                raise TypeError(f"{key} phải là int, str hoặc float")
        return super().__new__(cls, name, bases, attrs)

class ValidatedClass(metaclass=ValidationMeta):
    x = 1          # OK
    y = "string"   # OK
    # z = [1, 2, 3]  # TypeError khi định nghĩa class
Khi nào KHÔNG nên dùng: metaclass mạnh nhưng khó đọc và dễ khiến người sau "toát mồ hôi". Đa số nhu cầu "can thiệp lúc tạo class" ngày nay giải quyết gọn hơn bằng __init_subclass__ hoặc class decorator. Chỉ với tới metaclass khi thật sự cần.

Ví von: class là khuôn làm bánh, cái bánh là object. Metaclass là xưởng đúc khuôn - nơi quyết định cái khuôn đó được đúc thế nào, có đạt tiêu chuẩn trước khi xuất xưởng hay không.

14. Descriptor - bộ điều khiển truy cập thuộc tính

Descriptor là object định nghĩa hành vi khi thuộc tính được đọc/ghi/xoá, thông qua __get__, __set__, __delete__. Đây chính là cơ chế nằm dưới property, @staticmethod, @classmethod và cả phương thức thường. Dùng descriptor khi bạn muốn tái sử dụng logic kiểm soát thuộc tính (validate, tính toán, ghi log) ở nhiều nơi.

class Positive:
    def __set_name__(self, owner, name):
        self._name = "_" + name  # mỗi instance có ô lưu riêng

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return getattr(obj, self._name, None)

    def __set__(self, obj, value):
        if value < 0:
            raise ValueError("Phải là số dương!")
        setattr(obj, self._name, value)

class Circle:
    radius = Positive()  # dùng descriptor để validate

    @property            # property cũng là một descriptor
    def area(self):
        return 3.14159 * self.radius ** 2

c = Circle()
c.radius = 5
print(c.area)
# c.radius = -5  # ValueError: Phải là số dương!
Kết quả
78.53975
Cạm bẫy: descriptor được chia sẻ ở cấp class. Nếu bạn lưu giá trị vào chính descriptor (kiểu self._value) thì mọi instance dùng chung một ô nhớ - object này ghi đè object kia. Cách đúng là lưu theo từng instance (dùng __set_name__ + setattr(obj, ...) như trên).

Ví von: descriptor như người gác cổng đứng trước một thuộc tính. Mỗi lần ai đó muốn đọc hay ghi giá trị, đều phải đi qua người gác - người này có quyền kiểm tra, chặn, hoặc biến đổi yêu cầu.

15. Triết lý thiết kế: Zen of Python

Cuối cùng, thứ khiến Python là Python không nằm ở cú pháp mà ở triết lý. Gõ import this trong console, bạn sẽ thấy Zen of Python (do Tim Peters viết, chính là PEP 20) - 19 châm ngôn định hình cách người ta viết code Python "đúng vị".

import this
Kết quả
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Muốn nhanh hơn nữa cho phần code nóng, bạn còn có thể viết extension module bằng C/C++ (hoặc dùng Cython, ctypes) để đẩy phần nặng ra khỏi VM Python - cũng là cách nhiều thư viện khoa học (NumPy) đạt tốc độ.

Tóm tắt

  • Python chạy trên CPython: mã nguồn -> bytecode -> VM thực thi. Xem bytecode bằng dis.
  • Truyền tham số là "pass-by-object-reference": mutable đổi ra ngoài, gán lại thì không.
  • Mọi thứ đều là object - kể cả hàm, class và type.
  • GIL trói CPU-bound đa luồng; I/O-bound thì vẫn lợi. Cần đa nhân thật thì dùng multiprocessing (hoặc bản free-threaded 3.13+).
  • Tra cứu tên theo LEGB; sửa tầng ngoài phải khai báo global/nonlocal.
  • Generator lười (lazy), tiết kiệm RAM. MRO theo C3. GC = đếm tham chiếu + gom vòng lặp.
  • with, decorator, duck typing/EAFP, __slots__, metaclass, descriptor - bộ công cụ nâng cao để quản lý tài nguyên, bọc hành vi, và kiểm soát class/thuộc tính.

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