tricky question

[Temple-Daemon]

You’re building a small shop app. A teammate wrote this function so that each customer gets a bag they can add items to. It seems harmless, but the app keeps showing customers items they never added.

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

print(add_item(1), add_item(2), add_item(3, []))

a) Predict: What exact output appears on screen? Write all three lists.
b) Explain: Why do the first two results look identical, even though the calls happened one after another? Think about when Python creates the default value and when print actually prints.
c) Fix: Rewrite the function so every call without a bucket argument gets its own fresh list. Then prove it works by calling it twice and showing the results are different.

[mgkvibez]

a) Predicted output

[1, 2] [1, 2] [3]

b) Why the first two lists look identical

Two things combine here:

1. The default value is created once, when def runs, not on each call. Python evaluates bucket=[] a single time, when the function is defined, and stores that one list object on the function. Every call that omits bucket reuses that same list.

2. print evaluates all its arguments before printing anything. The calls happen in order:

   • add_item(1) appends 1 to the shared default list and returns that same list object (not a copy).
   • add_item(2) appends 2 to the same list and returns it again.
   • add_item(3, []) gets a brand new list, so it's unaffected: [3].

   Only after all three calls finish does print run. By then the shared list contains [1, 2], and the first two return values are two references to that one list. So both show [1, 2], even though the first call "should" have given [1].

This is also why customers see items they never added: all bag-less calls share one hidden bag.

c) The fix

Use None as a sentinel and create the list inside the function, so it's made fresh on every call:

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

first = add_item(1)
second = add_item(2)

print(first)          # [1]
print(second)         # [2]
print(first is second)  # False, they are different lists

Output:

[1]
[2]
False

Now each call without a bucket gets its own new list, and if you pass a list in (like add_item(3, my_bag)), it still adds to that list as expected. Using is None (rather than if not bucket) matters: it keeps an empty list you pass in from being silently replaced by a new one.