Least Astonishment and the Mutable Default Argument?

Question

Anyone tinkering with Python long enough has been bitten (or torn to pieces) by the following issue: def foo(a=[]): a.append(5) return aPython novices would expect this function to always return a list with only one element: `[5]`. The result is instead very different, and very astonishing (for a novice): >>> foo() [5] >>> foo() [5, 5] >>> foo() [5, 5, 5] >>> foo() [5, 5, 5, 5] >>> foo()A manager of mine once had his first encounter with this feature, and called it "a dramatic design flaw" of the language. I replied that the behavior had an underlying explanation, and it is indeed very puzzling and unexpected if you don't understand the internals. However, I was not able to answer (to myself) the following question: what is the reason for binding the default argument at function definition, and not at function execution? I doubt the experienced behavior has a practical use (who really used static variables in C, without breeding bugs?)**Edit**: Baczek made an interesting example. Together with most of your comments and Utaal's in particular, I elaborated further: >>> def a(): ... print("a executed") ... return [] ... >>> >>> def b(x=a()): ... x.append(5) ... print(x) ... a executed >>> b() [5] >>> b() [5, 5]To me, it seems that the design decision was relative to where to put the scope of parameters: inside the function or "together" with it?Doing the binding inside the function would mean that `x` is effectively bound to the specified default when the function is called, not defined, something that would present a deep flaw: the `def` line would be "hybrid" in the sense that part of the binding (of the function object) would happen at definition, and part (assignment of default parameters) at function invocation time.The actual behavior is more consistent: everything of that line gets evaluated when that line is executed, meaning at function definition.

Answer 1

This is a great question.

One of the aspects of Python that makes it really fun to work with is that it is compiled at runtime. It allows a lot of freedom with how we write code, but can also lead to some confusing results. Have you tried giving 'foo' a list after running it a few times?

foo() //-> [5]

foo() //-> [5,5]

foo([1,2,3]) //-> [1,2,3,5]

foo() //-> [5,5,5]

This happens because the Python compiler creates a unique foo object when foo is called using the default arguments. When we call foo() the first time, a foo object is instantiated and the 'a' variable is created within its namespace [foo.a]. The next time foo() is called using the defaults, the compiler recognizes that this function already exists. The same foo object is used, therefore the same 'a' variable is used.

I agree that this behavior is unexpected, but I would not call it a 'dramatic design flaw'. It is one of the ways in which Python is more of an object oriented language. This attribute of functions allows us to use a function as an object without having to build a class or give it a name. That's pretty cool, if you ask me!