📌 1. Mutable Default Arguments: Cái Bẫy Tai Hại Nhất Với Người Mới

Hãy xem đoạn mã tưởng chừng vô hại dưới đây, một lỗi kinh điển xuất hiện trong ít nhất một dự án của mọi lập trình viên:

# ⚠️ CODE BỊ LỖI LOGIC NGẦM:
def them_hang_vao_gio(san_pham, gio_hang=[]):
    gio_hang.append(san_pham)
    return gio_hang

print(them_hang_vao_gio("Táo"))   # Kết quả: ['Táo']
print(them_hang_vao_gio("Chuối")) # Kết quả: ['Táo', 'Chuối']  <-- TẠI SAO LẠI CÓ TÁO Ở ĐÂY?!

Bản chất cơ chế: Trong Python, các giá trị mặc định của tham số hàm được tính toán một lần duy nhất tại thời điểm hàm được định nghĩa (Definition Time), chứ không phải mỗi khi hàm được thực thi (Call Time). Danh sách (list) hay từ điển (dict) là kiểu dữ liệu có thể thay đổi (mutable). Khi bạn nạp file, Python tạo đúng một đối tượng danh sách duy nhất trong bộ nhớ và gán cho tham số gio_hang. Mọi lần gọi hàm tiếp theo mà không truyền tham số mới đều sẽ dùng chung đúng đối tượng đó!

# ✅ GIẢI PHÁP PYTHONIC CHUẨN MỰC:
def them_hang_chuan(san_pham, gio_hang=None):
    if gio_hang is None:
        gio_hang = []  # Tạo mới danh sách độc lập cho mỗi lần gọi hàm
    gio_hang.append(san_pham)
    return gio_hang

📌 2. List Comprehensions vs Generator Expressions: Dấu Ngoặc Định Đoạt Bộ Nhớ

Ngoặc vuông [] hay ngoặc tròn () không đơn thuần là sự khác biệt về mặt thẩm mỹ, chúng đại diện cho hai triết lý tính toán hoàn toàn trái ngược nhau:

import sys

# 1. List Comprehension: Cấp phát toàn bộ 10 triệu số vào RAM ngay lập tức
danh_sach_list = [x**2 for x in range(10_000_000)]
print(f"RAM chiếm dụng của List: {sys.getsizeof(danh_sach_list) / (1024**2):.2f} MB")
# Output: RAM chiếm dụng của List: ~85.17 MB (và còn ngốn bộ nhớ chứa từng số nguyên bên trong)

# 2. Generator Expression: Áp dụng cơ chế đánh giá lười (Lazy Evaluation)
bo_sinh_gen = (x**2 for x in range(10_000_000))
print(f"RAM chiếm dụng của Generator: {sys.getsizeof(bo_sinh_gen)} Bytes")
# Output: RAM chiếm dụng của Generator: ~104 Bytes!

Bài học ứng dụng: Nếu bạn chỉ cần duyệt qua dữ liệu một lần duy nhất (ví dụ: tính tổng, tìm kiếm điều kiện, ghi file theo luồng), hãy luôn ưu tiên sử dụng Generator Expression để giữ cho mức tiêu thụ bộ nhớ của ứng dụng ở mức gần như bằng 0.

📌 3. *args & **kwargs: Bản Chất Chỉ Là Đóng Gói (Packing) & Bung Gói (Unpacking)

Cái tên args và kwargs thực chất chỉ là quy ước cộng đồng. “Phép màu” nằm ở chính các dấu sao: một dấu sao (*) dành cho Tuple (tham số vị trí) và hai dấu sao (**) dành cho Dictionary (tham số định danh).

def ghi_nhat_ky(*args, **kwargs):
    print(f"Positional Tuple: {args}")
    print(f"Keyword Dict: {kwargs}")

ghi_nhat_ky("Lỗi 404", "Database", ma_loi=500, moi_truong="Production")
# Positional Tuple: ('Lỗi 404', 'Database')
# Keyword Dict: {'ma_loi': 500, 'moi_truong': 'Production'}

# Kỹ thuật Unpacking siêu tiện lợi:
toan_bo_cau_hinh = {"host": "localhost", "port": 5432, "timeout": 30}
ket_noi_db(**toan_bo_cau_hinh)  # Tương đương kết nối với từng tham số riêng biệt

📌 4. Decorators: Bản Chất Là Những Hàm Nhận Vào Một Hàm Và Trả Ra Một Hàm Khác

Rất nhiều người coi ký hiệu @decorator là một thứ gì đó huyền bí. Nhưng thực chất nó chỉ là cú pháp đường (Syntactic Sugar). Câu lệnh @timer phía trên hàm xu_ly_du_lieu hoàn toàn tương đương với phép gán: xu_ly_du_lieu = timer(xu_ly_du_lieu).

import time
from functools import wraps

def do_thoi_gian(func):
    @wraps(func)  # Giữ nguyên docstring và tên hàm gốc (__name__)
    def wrapper(*args, **kwargs):
        bat_dau = time.perf_counter()
        ket_qua = func(*args, **kwargs)
        tong_thoi_gian = time.perf_counter() - bat_dau
        print(f"⏱️ Hàm '{func.__name__}' thực thi trong: {tong_thoi_gian:.5f} giây")
        return ket_qua
    return wrapper

@do_thoi_gian
def tai_du_lieu_nang(so_luong):
    return sum(i**2 for i in range(so_luong))

tai_du_lieu_nang(5_000_000)
# Output: ⏱️ Hàm 'tai_du_lieu_nang' thực thi trong: 0.38421 giây

📌 5. Phân Định Giữa “==” và “is”: Giá Trị Nội Dung vs Địa Chỉ Ô Nhớ

Sự nhầm lẫn giữa hai toán tử này là nguyên nhân gây ra vô số lỗi logic khó phát hiện khi triển khai các hệ thống thanh toán hoặc xác thực người dùng:

• == (Equality): So sánh xem giá trị nội dung của hai đối tượng có bằng nhau hay không.
• is (Identity): So sánh xem hai biến có đang trỏ đến cùng một địa chỉ ô nhớ duy nhất trong RAM hay không (so sánh id(a) == id(b)).

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)  # True: Cùng chứa các số 1, 2, 3
print(a is b)  # False: Nằm ở hai vùng ô nhớ RAM hoàn toàn khác nhau!

# Quy chuẩn vàng: Chỉ dùng 'is' khi so sánh với các hằng số Singleton:
if ket_qua is None:  # ✅ Rất chuẩn xác và tối ưu
    pass

📌 6. Context Managers & Câu Lệnh “with”: Cơ Chế Giải Phóng Tài Nguyên Hoàn Hảo

Khi mở một tệp tin, mở một cổng socket mạng hoặc thiết lập khóa luồng (thread lock), nếu ứng dụng gặp lỗi crash giữa chừng, tài nguyên đó sẽ bị kẹt lại trong hệ điều hành gây rò rỉ (Resource Leak). Câu lệnh with bảo đảm việc dọn dẹp luôn được thực thi nhờ hai phương thức ngầm __enter__ và __exit__.

class KetNoiDatabase:
    def __enter__(self):
        print("🔌 Khởi tạo kết nối an toàn tới cơ sở dữ liệu...")
        return self
        
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("🔒 Tự động đóng kết nối và giải phóng pool kết nối!")
        # Dù có lỗi ngoại lệ ném ra trong khối with, __exit__ vẫn luôn được gọi 100%

with KetNoiDatabase() as db:
    print("   -> Đang thực thi truy vấn dữ liệu...")

📌 7. Closures & Quy Tắc Phạm Vi LEGB (Local – Enclosing – Global – Built-in)

Một Closure (bao đóng) xảy ra khi một hàm lồng bên trong “ghi nhớ” và có quyền truy cập vào các biến thuộc hàm cha bao bọc nó, ngay cả khi hàm cha đã kết thúc quá trình thực thi và bị xóa khỏi Call Stack.

def tao_bo_dem(buoc_nhay=1):
    gia_tri_hien_tai = 0
    def tang_len():
        nonlocal gia_tri_hien_tai  # Báo cho Python biết ta muốn thay đổi biến ở phạm vi Enclosing
        gia_tri_hien_tai += buoc_nhay
        return gia_tri_hien_tai
    return tang_len

dem_5 = tao_bo_dem(5)
print(dem_5())  # Output: 5
print(dem_5())  # Output: 10 (Duy trì trạng thái mà không cần khai báo Class!)

📌 8. Dunder Methods & Mô Hình Dữ Liệu Pythonic (Python Data Model)

Dunder (viết tắt của Double Underscore như __init__, __repr__, __len__, __getitem__) cho phép lớp do bạn tự định nghĩa có thể tương tác tự nhiên với các hàm tích hợp sẵn của Python như len(), duyệt vòng lặp for hay truy xuất chỉ mục bằng ngoặc vuông obj[0].

class GioHangVip:
    def __init__(self):
        self._danh_sach = []
        
    def them(self, mon):
        self._danh_sach.append(mon)
        
    def __len__(self):
        return len(self._danh_sach)
        
    def __getitem__(self, vi_tri):
        return self._danh_sach[vi_tri]

gio = GioHangVip()
gio.them("Laptop"); gio.them("Bàn phím")
print(len(gio))      # Output: 2  <-- Hoạt động chuẩn xác với hàm len()
print(gio[0])        # Output: 'Laptop' <-- Hỗ trợ slice và indexing như mảng thật!

📌 9. First-Class Functions & Ranh Giới Giữa Lambda Với List Comprehension

Trong Python, hàm được xem là đối tượng công dân hạng nhất (First-Class Citizens): bạn có thể gán hàm vào biến, truyền hàm làm đối số cho hàm khác và trả về hàm từ bên trong hàm. Tuy nhiên, việc lạm dụng lambda kết hợp với map() hay filter() thường làm code trở nên rối rắm và khó đọc hơn nhiều so với cú pháp List Comprehension.

ds_so = [1, 2, 3, 4, 5]

# ❌ Khó đọc theo phong cách functional cổ điển:
bp_chan = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, ds_so)))

# ✅ Rõ ràng, trực quan, đậm chất Pythonic:
bp_chan_chuan = [x**2 for x in ds_so if x % 2 == 0]

📌 10. Generator Functions & “yield”: Vũ Khí Xử Lý Dữ Liệu Lớn (Big Data)

Khác với lệnh return sẽ kết thúc hoàn toàn hàm và hủy sạch Call Frame, từ khóa yield sẽ tạm dừng việc thực thi và ghi nhớ chính xác trạng thái cục bộ của hàm. Khi hàm gọi phương thức next(), tiến trình sẽ tiếp tục chạy ngay tại vị trí vừa dừng lại.

def doc_file_log_khong_lo(duong_dan_file):
    with open(duong_dan_file, "r", encoding="utf-8") as f:
        for dong in f:
            if "CRITICAL_ERROR" in dong:
                yield dong.strip()  # Trả về từng dòng lỗi mà không tải file 50GB vào RAM!

# Xử lý mượt mà trên tệp tin dung lượng vượt xa dung lượng RAM vật lý của máy trạm:
for loi in doc_file_log_khong_lo("/var/log/server_access.log"):
    gui_canh_bao_telegram(loi)