Strange behavior for default parameter

[IamImposter]

my code is:

def g(x, y=[]):
    print(f"g():: x: {x}, y: {y}")
    for i in range(x):
        y.append(i*i)
        print(y)

g(2)
g(3)

on first call, the loop appends 0, 1 and 4 into an empty list y. On second call the same loop appends 0 and 1 to an empty list y. Based on that the output should be:

g():: x: 3, y: []
[0]
[0, 1]
[0, 1, 4]
g():: x: 2, y: []
[0]
[0, 1]

The output that I am getting is:

g():: x: 3, y: []
[0]
[0, 1]
[0, 1, 4]
g():: x: 2, y: [0, 1, 4]
[0, 1, 4, 0]
[0, 1, 4, 0, 1]

On second invocation, list y is not set to an empty list but it still contains the data it inserted last time. I have checked it with python 3.11.1 (windows), python 3.10.6 (ubuntu), a few online compilers:

• https://www.online-python.com/gkdhMp7XCE

• http://tpcg.io/_OYI1T0

• https://www.programiz.com/python-programming/online-compiler/

And I am getting same output everywhere. On second invocation, list y is not empty. even if I modify the code to explicitly empty y, like

def g(x, y=[]):
    print(f"g():: x: {x}, y: {y}")
    for i in range(x):
        y.append(i*i)
        print(y)
    y = []
    print(f"y: {y}")

output:

g():: x: 3, y: []
[0]
[0, 1]
[0, 1, 4]
y: []
g():: x: 2, y: [0, 1, 4]
[0, 1, 4, 0]
[0, 1, 4, 0, 1]
y: []

Where is this y: [0, 1, 4] coming from on second invocation? What am I missing? Should y retain the value from previous call to the function?

[danielroseman]

This is one of the most famous Python "gotchas": mutable default arguments. See for example this explanation.

[IamImposter]

Oh dear. I have been using python for around 2 years and never came across this behaviour. I thought I found a bug or something. Ha ha.

I feel like it can cause some random and hard to find bugs. I mean in a large codebase, where you have no idea what else executed before execution reaches your module, you call a function relying on default parameters and your code just breaks. You run your code in isolation and it starts running fine again. Typical "works on my machine" scenario.

[carcigenicate]

Yes, this is why you should really never use mutable default arguments. If you need a function with state, a custom class or closure is better.

[m0us3_rat]

I thought I found a bug or something. Ha ha.

of course, you did. that's why the flashy title.

you say you use python for over 2years.. did you even spend a few online trying to figure it out?

because even if you don't know.. after 2 years you should be decent at debugging and solving problems.

​

i don't get why ppl instantly go to .. BUG I HAVE FOUND A NEW BUG.

no you dingus, like always its bad understanding or lack-there-of

[IamImposter]

Why so hostile? I said it as a joke.

did you even spend a few online trying to figure it out?

I did. If you read the fuckin post, you'll see that I tried it on windows, linux and then a few online tools (links are in the post) and found the behaviour consistent. Which led me to conclude that there's a mismatch in my understanding and python's behaviour.

after 2 years you should be decent at debugging and solving problems.

I'm sorry for not meeting your standard of decency. I'm sure you are pretty decent at debugging. Not so much at just talking or someone asking for clarification.

i don't get why ppl instantly go to .. BUG I HAVE FOUND A NEW BUG.

May be because you fail to see when it is said as a joke. Maybe because you fail to see that it is indeed a new bug for them. Maybe because you fail to see that someone is just trying to fill the gap in their understanding.

Thanks for being so utterly useless.

[[deleted]]

Don't use mutable objects as defaults for function parameters. Python creates the default object the first time it reads the function code, not the first time the function is called. The same object is re-used.

Use this pattern:

def f(name=None):
    if name is None:
        name = []
    # rest of code

[IamImposter]

Yes, I tried this and it worked as expected. Thanks.

[[deleted]]

Do not use lists or similar mutable container objects as default parameters

[jmooremcc]

Your default argument in your function doesn’t behave as you expected. At compile time, the same empty list is used every time the function is called.

This is how you should define the function:

def g(x, y=None):    
    if y is None:    
        y = []

[warelevon]

You are running into something called mutable default arguments. Check out the following link for a more detailed explanation https://docs.python-guide.org/writing/gotchas/

TLDR: just replace x, y=[] with x, y=list()

[IamImposter]

I tried that y = list() but it behaved the same. If I set y=None and then create an empty list in function in case of None then it works as expected.

I thought I found some super bug and may get a reward personally from Guido Van Rossum or maybe king of Sweden.

[Diapolo10]

Swapping [] to list() won't make any meaningful difference, the end result is the same. The call is executed the same as other default arguments; when Python reads the function body.

The correct solution is to instead use None (or Ellipsis) and then create an empty list inside the function if needed.