5

Python Tutorial 4.7.1. Default Argument Values states the following:

Important warning: The default value is evaluated only once. This makes a difference when the default is a mutable object such as a list, dictionary, or instances of most classes. For example, the following function accumulates the arguments passed to it on subsequent calls:

def f(a, L=[]):
    L.append(a)
    return L

print f(1)
print f(2)
print f(3)

This will print

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

I don't quite understand the meaning of "evaluated only once" in terms of memory management. Apparently, the default value of the function is evaluated once when the function is first called and stored in a separate memory address even after the function has ended. (according to my understanding, after the function ended, all local variables should be freed?)

Am I correct?

Antti Haapala -- Слава Україні
  • 129,958
  • 22
  • 279
  • 321
pspencil
  • 295
  • 1
  • 10

4 Answers4

12

In Python, functions are objects too, and the defaults are stored with the function object. Defaults are not locals; it is just that when the function is called, the arguments are bound to a default when not given an explicit value.

When Python encounters a def <functionname>(<arguments>): statement, it creates a function object for you there and then; this is 'definition time'; the function is not called but merely created. It is then that defaults are evaluated and stored, in an attribute on the function object.

Then when you call the function, the defaults have already been created and are used when you didn't provide a more concrete value for the argument. Because the defaults are stored with the function object, you get to see changes to mutable objects between function calls.

The locals are still cleared up of course, but as they are references (all identifiers in Python are), the objects they were bound to are only cleared up if nothing else is referencing them anymore either.

You can take a look a the defaults of any function object:

>>> def foo(bar='spam', eggs=[]):
...     eggs.append(bar)
...     return eggs
... 
>>> foo.__defaults__
('spam', [])
>>> foo()
['spam']
>>> foo.__defaults__
('spam', ['spam'])
>>> foo() is foo.__defaults__[1]
True

The foo() function has a __defaults__ attribute, a tuple of default values to use when no values for the arguments have been passed in. You can see the mutable list change as the function is called, and because the function returns the eggs list, you can also see that it is the exact same object as the second value in that tuple.

If you don't want your defaults to be shared and instead need a new value for a parameter every time the function is called, but the parameter is not given, you need to set the default value to a sentinel object. If your parameter is still set to that sentinel in the function body, you can execute code to set a fresh default value. None is usually the best choice:

def foo(bar='spam', eggs=None):
    if eggs is None:
        eggs = []

If it should be possible to use None as a non-default value, use a singleton sentinel created beforehand:

_sentinel = object()

def foo(bar='spam', eggs=_sentinel):
    if eggs is _sentinel:
        eggs = []
Martijn Pieters
  • 1,048,767
  • 296
  • 4,058
  • 3,343
1

A function is just an object in python, that is created using the def syntax. Default values are stored within the function object when the function is defined, and they are not re-evaluated later.

This is sometimes used to create function variables that persist to subsequent invocations. You can use the __defaults__ methods to check what the default values are for your function.

A common way to initialize new objects instead of reusing the same is:

def f(a, L=None):
    if L is None:
        L = []

    L.append(a)
    return L

You can check this page for more details.

enrico.bacis
  • 30,497
  • 10
  • 86
  • 115
1

The function that you have defined f is an object in its own regard. When you define defaults, these defaults are bound to the function that you have created.

You can see this in action:

>>> def f(a, L=[]):
...    L.append(a)
...    return L

>>> print id(f)
4419902952

>>> print f.__defaults__
([],)
>>> f(1)
[1]

>>> print id(f)
4419902952

>>> print f.__defaults__
([1],)

edit, further, you can see that the list container does not change either:

>>> print id(f.__defaults__[0])
4419887544
>>> f(2)
[1, 2]
>>> print id(f.__defaults__[0])
4419887544

On each subsequent call, the default list ("L") of your f function will have your a value appended.

0

Sorry this answer was meant for a different question, but I'll leave it here as a reference if anyone who wants to look at it. Define once means that at the first point when the code is executed, the default variable gets assigned to an object which is retained within the function object itself.

Notice only 1 object address gets printed, the default list object is used. 

  def f(a, L=[]):
    print("id default: ", id(L))
    L.append(a)
    print("id used: ", id(L)
    return L

Notice 2 different object addresses are printed, when you perform L=[] within the function, you are binding L to a different list object, therefore the default list object does not get change. 

def f(a, L=[]):
    print("id default: ", id(L))
    if L == []:
        L = []
    L.append(a)
    print("id used: ", id(L))      
    return L

The function above is basically the same as the one below except it uses the None object instead of a empty list object. 

def f(a, L=None):
    print("id default", id(L))
    if L is None:
        L = []
   L.append(a) 
   print("id used: ", id(L))      
   return L
KN Nguyen
  • 1
  • 2