Mutable default arguments - Cái bẫy nguy hiểm!

Hiện tượng lạ

def add_item(item, lst=[]):
    lst.append(item)
    return lst

# Lần 1
print(add_item("apple"))   # ['apple'] ✅

# Lần 2
print(add_item("banana"))  # ['apple', 'banana'] ❌ What?!

# Lần 3
print(add_item("orange"))  # ['apple', 'banana', 'orange'] ❌❌

What the Python?! Tại sao list cứ tích lũy dữ liệu từ lần gọi trước?! 😱

Giải thích

Default arguments được tạo 1 LẦN DUY NHẤT

Khi Python định nghĩa function, default arguments được evaluate 1 lần và tái sử dụng cho mọi lần gọi!

def add_item(item, lst=[]):  # [] được tạo 1 LẦN duy nhất khi define
    lst.append(item)
    return lst

# Mỗi lần gọi function DÙNG CHUNG list đó!
print(id(add_item.__defaults__[0]))  # Địa chỉ bộ nhớ

result1 = add_item("apple")
print(id(result1))  # Cùng địa chỉ!

result2 = add_item("banana")
print(id(result2))  # Cùng địa chỉ!

# Tất cả trỏ đến CÙNG 1 list!

Xem default object

def add_item(item, lst=[]):
    lst.append(item)
    return lst

# Xem default values
print(add_item.__defaults__)  # ([],)

# Gọi function
add_item("apple")
print(add_item.__defaults__)  # (['apple'],) <- Default đã thay đổi!

add_item("banana")
print(add_item.__defaults__)  # (['apple', 'banana'],) <- Tiếp tục thay đổi!

Tại sao lại thiết kế như vậy?

Lý do kỹ thuật

# Default arguments evaluate LÚC DEFINE, không phải lúc CALL

def create_time(time=datetime.now()):  # now() gọi 1 lần lúc define!
    return time

# Cả 3 lần gọi đều trả về CÙNG 1 thời điểm
print(create_time())  # 2025-12-12 10:00:00
time.sleep(2)
print(create_time())  # 2025-12-12 10:00:00 <- GIỐNG NHAU!

Performance benefit

# Nếu evaluate mỗi lần gọi → chậm
# Với immutable: không ảnh hưởng gì
# Với mutable: gây bug!

def process(data, config={"mode": "fast"}):  # Dict tạo 1 lần
    # Nếu phải tạo dict mỗi lần gọi → chậm không cần thiết
    pass

Các kiểu mutable gặp vấn đề

List

def append_to(element, lst=[]):  # ❌ BUG!
    lst.append(element)
    return lst

print(append_to(1))  # [1]
print(append_to(2))  # [1, 2] <- Oops!

Dictionary

def add_user(name, users={}):  # ❌ BUG!
    users[name] = True
    return users

print(add_user("Alice"))  # {'Alice': True}
print(add_user("Bob"))    # {'Alice': True, 'Bob': True} <- Oops!

Set

def add_to_set(item, s=set()):  # ❌ BUG!
    s.add(item)
    return s

print(add_to_set(1))  # {1}
print(add_to_set(2))  # {1, 2} <- Oops!

Custom objects

class Counter:
    def __init__(self):
        self.count = 0

def increment(counter=Counter()):  # ❌ BUG!
    counter.count += 1
    return counter.count

print(increment())  # 1
print(increment())  # 2 <- Oops! Cùng 1 object
print(increment())  # 3

Giải pháp

✅ Solution 1: Dùng None

def add_item(item, lst=None):  # ✅ ĐÚNG
    if lst is None:
        lst = []  # Tạo list MỚI mỗi lần gọi
    lst.append(item)
    return lst

print(add_item("apple"))   # ['apple']
print(add_item("banana"))  # ['banana'] ✅
print(add_item("orange"))  # ['orange'] ✅

✅ Solution 2: Sentinel value

_sentinel = object()

def add_item(item, lst=_sentinel):
    if lst is _sentinel:
        lst = []
    lst.append(item)
    return lst

✅ Solution 3: Docstring với immutable

def add_item(item, lst=None):
    """
    Add item to list.

    Args:
        item: Item to add
        lst: List to add to (default: empty list)
    """
    if lst is None:
        lst = []
    lst.append(item)
    return lst

Patterns đúng

Pattern 1: None-default

# Lists
def process_items(items=None):
    if items is None:
        items = []
    # ...

# Dicts
def configure(options=None):
    if options is None:
        options = {}
    # ...

# Sets
def unique_items(items=None):
    if items is None:
        items = set()
    # ...

Pattern 2: Copy từ template

DEFAULT_CONFIG = {"mode": "fast", "debug": False}

def process(config=None):
    if config is None:
        config = DEFAULT_CONFIG.copy()  # COPY!
    # Modify config safely
    config["timestamp"] = time.time()
    return config

Pattern 3: Immutable defaults

# ✅ OK - Immutable
def greet(name="World"):  # str là immutable
    return f"Hello, {name}"

def multiply(x, y=1):  # int là immutable
    return x * y

def process(data, mode="fast"):  # str là immutable
    pass

Khi nào mutable default hữu ích?

Use case: Caching

def fibonacci(n, cache={}):  # Intentional shared cache!
    if n in cache:
        return cache[n]

    if n < 2:
        return n

    result = fibonacci(n-1, cache) + fibonacci(n-2, cache)
    cache[n] = result
    return result

# Cache được share giữa các lần gọi
print(fibonacci(10))  # Tính và cache
print(fibonacci.__defaults__[0])  # {0: 0, 1: 1, 2: 1, ...}
print(fibonacci(20))  # Dùng cached values

Use case: Singleton pattern

def get_connection(conn=[]):  # Intentional!
    if not conn:
        conn.append(create_expensive_connection())
    return conn[0]

# Dùng chung 1 connection
db1 = get_connection()
db2 = get_connection()
assert db1 is db2  # True - cùng connection

⚠️ Lưu ý: Những use cases này NÊN document rõ ràng!

Bugs thực tế

Bug 1: Flask route với default dict

# SAI
@app.route('/api/data')
def get_data(filters={}):  # ❌ Shared dict!
    filters['timestamp'] = time.time()
    return query_db(filters)

# Request 1: filters = {'timestamp': 100}
# Request 2: filters = {'timestamp': 100, 'timestamp': 200} <- Lỗi!

# ĐÚNG
@app.route('/api/data')
def get_data(filters=None):  # ✅
    if filters is None:
        filters = {}
    filters['timestamp'] = time.time()
    return query_db(filters)

Bug 2: Class method với default list

class TaskManager:
    # SAI
    def add_task(self, task, tasks=[]):  # ❌
        tasks.append(task)
        return tasks

    # ĐÚNG
    def add_task(self, task, tasks=None):  # ✅
        if tasks is None:
            tasks = []
        tasks.append(task)
        return tasks

Bug 3: Logging function

# SAI
def log_event(event, history=[]):  # ❌ Shared history!
    history.append({
        'event': event,
        'time': time.time()
    })
    return history

# ĐÚNG
def log_event(event, history=None):  # ✅
    if history is None:
        history = []
    history.append({
        'event': event,
        'time': time.time()
    })
    return history

Testing để phát hiện

def test_add_item():
    # Test multiple calls
    result1 = add_item("apple")
    result2 = add_item("banana")

    # Nếu có bug, result2 sẽ chứa cả "apple"
    assert "apple" not in result2  # Sẽ fail nếu dùng lst=[]

    # Hoặc check length
    assert len(result2) == 1  # Should only have 1 item

Pylint warning

# Pylint sẽ cảnh báo:
def add_item(item, lst=[]):  # W0102: Dangerous default value [] as argument
    pass

# Cách tắt warning (KHÔNG khuyến khích)
def add_item(item, lst=[]):  # pylint: disable=dangerous-default-value
    # Chỉ nếu bạn biết mình đang làm gì!
    pass

Best Practices

✅ Luôn làm

# 1. Dùng None cho mutable defaults
def process(items=None):
    if items is None:
        items = []

# 2. Document nếu intentional
def fibonacci(n, cache={}):  # pylint: disable=dangerous-default-value
    """
    Fibonacci with caching.
    WARNING: cache is intentionally shared between calls.
    """
    pass

# 3. Type hints rõ ràng
from typing import List, Optional

def add_item(item: str, lst: Optional[List[str]] = None) -> List[str]:
    if lst is None:
        lst = []
    lst.append(item)
    return lst

❌ Tránh làm

# 1. Mutable defaults
def process(data=[]):  # ❌
    pass

# 2. Default từ function call
def log(msg, timestamp=datetime.now()):  # ❌ Evaluate 1 lần!
    pass

# 3. Default object creation
def init(config=Config()):  # ❌ Create 1 lần!
    pass

Tóm tắt

Default Type	Safe?	Example	Fix
lst=[]	❌	Shared list	lst=None
d={}	❌	Shared dict	d=None
s=set()	❌	Shared set	s=None
obj=Obj()	❌	Shared object	obj=None
x=0	✅	Immutable	OK
name=""	✅	Immutable	OK
flag=True	✅	Immutable	OK
t=(1,2)	✅	Immutable	OK

Ghi nhớ

KHÔNG BAO GIỜ dùng mutable objects làm default arguments!

• ❌ lst=[], d={}, s=set(), obj=Obj()
• ✅ Luôn dùng None và tạo mới trong function
• ⚠️ Default được evaluate 1 LẦN lúc define, KHÔNG phải mỗi lần gọi
• 🐛 Đây là BUG CỰC KỲ PHỔ BIẾN với Python beginners
• 🔧 Pylint sẽ warning: W0102: Dangerous default value

Pattern an toàn:

def my_func(arg, mutable_arg=None):
    if mutable_arg is None:
        mutable_arg = []  # or {} or set()
    # Use mutable_arg safely

Nhớ: Default arguments = function attributes, không phải local variables!