Why is a shared empty list a risky default for a Python function?

The default list is made when Python defines the function. Calls that leave out items reuse that same list; they do not each get a newly made empty one. If the function appends to it, a later call that also leaves out items can see what was appended earlier. [S1]

Here is a small illustrative example:

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

print(add_item("tea"))
print(add_item("bread"))

The second call can return ['tea', 'bread'], rather than starting with only ['bread'], because both calls use the shared default list. This matters whenever a function mutates a default object, for example by appending or removing list entries. [S1]

Use None to signal that no list was supplied, and make the list inside the function. That gives each call with an omitted argument its own list:

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item("tea"))    # ['tea']
print(add_item("bread"))  # ['bread']

This is the pattern recommended in the Python tutorial for a mutable default such as a list. [S1] The check is specifically is None, rather than a general truthiness check: an explicitly passed empty list is still a list the caller supplied, and the function should use that list rather than silently replace it.

Only calls where items is None get a newly created list from this pattern. If a caller supplies a list, the function uses that supplied list; appending to it changes the list the caller passed. That is often useful, but it is different from the omitted-argument behavior.

For example:

shared = ["tea"]
result = add_item("bread", shared)

print(result)  # ['tea', 'bread']
print(shared)  # ['tea', 'bread']

If you want to avoid changing a caller-provided list too, make a copy inside the function before modifying it. That is a separate behavior choice: the None pattern fixes accidental sharing of the default; it does not promise that supplied arguments will remain untouched.

Look at each parameter default and ask whether it is a mutable object, especially a list. Then look inside the function for operations that change it, such as append, item assignment, or removal. If a mutable default is being changed, decide whether the function should maintain shared state intentionally or start fresh when the argument is omitted. For the latter, use None and initialize the object inside the function. [S1]

A compact review example:

# Risky if the function changes items
def collect(value, items=[]):
    items.append(value)
    return items

# Fresh list when omitted
def collect(value, items=None):
    if items is None:
        items = []
    items.append(value)
    return items

The Python tutorial explains the shared-default behavior and the None alternative. Choose based on whether sharing or modifying a caller’s list is part of that function’s intended behavior.