How Can I Avoid Unexpected Behavior with Mutable Default Arguments in Python?

Avoiding Default Parameter Gotchas in Python's Early Binding

When using default parameters in Python, it's essential to be aware of the early binding behavior, which can lead to unexpected results, particularly with mutable default arguments. This article addresses this issue and provides a solution to create a function that consistently uses a new empty list as the default parameter.

The Problem

Consider the following function:

def my_func(working_list=[]):
    working_list.append("a")
    print(working_list)

When this function is called for the first time without an explicit argument, Python creates a new empty list as the default value for working_list. However, subsequent calls without an explicit argument will use the same list created during the initial call, resulting in cumulative updates to the list.

The Solution

To avoid this behavior, the recommended approach is to use None as the default parameter and explicitly test for it within the function body. This can be achieved as follows:

def my_func(working_list=None):
    if working_list is None: 
        working_list = []

    # alternative:
    # working_list = [] if working_list is None else working_list

    working_list.append("a")
    print(working_list)

By setting the default parameter to None, a new empty list will be created every time the function is called without an explicit argument.

Additional Considerations

The Python documentation recommends using is None for comparisons with None. This is the preferred style according to PEP 8, which advises against using equality operators (== and !=) for comparisons to singletons like None.

The above is the detailed content of How Can I Avoid Unexpected Behavior with Mutable Default Arguments in Python?. For more information, please follow other related articles on the PHP Chinese website!