What do you think the second print will show? Go!

This YouTube video presents a coding puzzle related to Python's list behavior. The core of the problem lies in understanding how default mutable arguments are handled in function definitions.

Key Concepts

• Mutable Default Arguments: The central concept is the behavior of default arguments that are mutable data types (like lists or dictionaries) in Python functions.
• List Appending: The append() method for Python lists.
• Function Scope and State: How variables and their states persist or are re-initialized within function calls.

The Coding Puzzle

The video presents a Python code snippet:

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

print(add_item(1))
print(add_item(2))

The question posed to the viewer is: "What do you think the second print will show?"

Explanation of the Behavior

The presenter explains that the expected output, based on a naive understanding of function calls, might be [2]. However, the actual output is [1, 2]. This discrepancy arises because the default list my_list=[] is created only once when the function add_item is defined, not each time the function is called.

• First Call: add_item(1) is called. The default my_list (which is initially empty) is used. 1 is appended to it, making my_list become [1]. This modified list [1] is then returned.
• Second Call: add_item(2) is called. Crucially, the same default my_list object from the first call is reused. Since it already contains [1], 2 is appended to it, resulting in [1, 2]. This list [1, 2] is then returned.

The Problem with Mutable Defaults

The core issue is that mutable default arguments retain their state across multiple calls to the function. This can lead to unexpected side effects and bugs if the programmer assumes a fresh default object is created for each call.

The Corrected Approach

The video implicitly suggests a common and recommended pattern to avoid this issue: using None as the default and creating the mutable object inside the function if it's None.

A corrected version of the function would look like this:

def add_item_corrected(item, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(item)
    return my_list

print(add_item_corrected(1))
print(add_item_corrected(2))

In this corrected version:

• First Call: add_item_corrected(1) is called. my_list is None. A new empty list [] is created and assigned to my_list. 1 is appended, making my_list [1]. This list is returned.
• Second Call: add_item_corrected(2) is called. my_list is again None (because the default None is used, not a persistent object). A new empty list [] is created and assigned to my_list. 2 is appended, making my_list [2]. This list is returned.

The output of the corrected code would be:

[1]
[2]

Conclusion/Takeaway

The video highlights a common pitfall in Python programming related to mutable default arguments. It emphasizes the importance of understanding that default mutable objects are created only once at function definition time, leading to shared state across calls. The recommended solution is to use None as the default and instantiate mutable objects within the function body when needed. The presenter encourages viewers to share their initial thoughts and answers in the comments, fostering community engagement around the problem.