0
def func(arg1,arg2=[]):
    var = arg2
    var.append(arg1)
    return var

func("hello")
print("case1 output --> ",func("world"))

def func2(arg1,arg2):
    var = arg2
    var.append(arg1)
    return var

func2("hello",[])
print("case2 output --> ",func2("world",[])

This gives the output as -
case1 --> ['hello' , 'world']
case2 --> ['world']
First of all, this was a bit of shock to me according to my understanding from what I have come across about how formal and actual arguments, local variables and functions in python work. Now that I have seen the output in both the cases and have made the following assumptions.

Whenever a function is called, first of all there is an assignment operation as formal argument = actual argument which brings the formal argument in the local scope of the function. Case 1 is special because it has a default argument which is mutable. When the function is called for the first time, a list-type object gets mutated and returned. Now the function gets called second time, instead of reassignment of formal argument arg2 which will create a new empty list-type object, it mutates the same object which was mutated the last time. This means somehow, this function remembers the state of its default formal arguments which were mutated earlier. The same doesn't happen in case 2 where both are required arguments and hence it creates a new object each time the function is called. This seems odd at the first glance. But I am still not able to understand how this works exactly since this has completely changed my notion of how functions work in python at least as a beginner.

  1. Whatever my assumption is about this concept, is it correct and meaningful?
  2. Is there any specific reason why the function doesn't reassign arg2 = [ ] and create a new list object?
  3. Isn't a function supposed to forget the objects which only exist in its local scope ?
  4. Any detailed explanation of how this is exactly happening ? I would really like to know how the function is internally remembering the state of its formal argument even being present only in its local scope ?
Dishant Arora
  • 39
  • 4
  • Probable duplicate: https://stackoverflow.com/questions/1132941/least-astonishment-and-the-mutable-default-argument – chepner Feb 18 '19 at 17:59
  • The important thing to understand here is that the *value default arguments* gets evaluated *only once* at *function definition time*. This object gets reassigned to the default argument's identifier (unless the caller passes another object) at each invocation, but you are re-assigning *the same object*. All that the function has is a reference to an object. – juanpa.arrivillaga Feb 18 '19 at 18:01
  • Internally, you can look at `func.__defaults__` to see the tuple of default parameter values that the `function` object maintains. That's how different invocations of `func` use the *same* list when called without a second argument. – chepner Feb 18 '19 at 18:02
  • Note, there are several good answers in the linked duplicate. The accepted answer is actually perhaps not the most informative. Make sure to look at others for details about how this works. – juanpa.arrivillaga Feb 18 '19 at 18:04

0 Answers0