python function definition: function returning local to a global scope

Question

def foo(a, l=[]):
   l.append(a)
   return l

print foo(10)
Result: [10]

print foo(20)
Result: [10, 20]

Why is this happening?

`list` are mutable, they operated on their references rather then object. — Vishnu Upadhyay, Nov 17 '14 at 06:44
I wish people wouldn't downvote questions like this. Yes, this question comes by twice a week, but this is a legitimately confusing topic; if you don't already understand what's happening, it's not obvious what to search for to find answers. — Andrew Gorcester, Nov 17 '14 at 06:50
possible duplicate of ["Least Astonishment" in Python: The Mutable Default Argument](http://stackoverflow.com/questions/1132941/least-astonishment-in-python-the-mutable-default-argument) — Lukas Graf, Nov 17 '14 at 07:14

score 2 · Answer 1 · answered Nov 17 '14 at 06:49

This line:

def foo(a, l=[]):

is creating a list at definition time.

That same list is being used every time the function is called.

Normally something like def foo(a, l="some string"): would work fine, but that's because string literals, integers and such are immutable and therefore it doesn't matter if every instance of the function accesses the same object in memory. Lists, on the other hand, are mutable.

You can get around this like so:

def foo(a, l=None):
    if l is None:
        l = []
    l.append(a)
    return l

This also creates a new list, but only upon execution of the function, in local scope. It won't reuse the same one.

score 1 · Answer 2 · answered Nov 17 '14 at 06:50

1

When you give a default value to a function argument in python, it gets initialized only ONCE. That means even if you call your foo() a million times, you are appending to the SAME list.

answered Nov 17 '14 at 06:50

mulog

11
1
1

Vishnu Upadhyay · Answer 3 · 2014-11-17T07:17:00.303

print foo(10)  
print foo(20, [])

output:- [20]

this time you are sending another list reference so value will be inserted in another list reference.

If you do

def foo(a, l=[]):
    print id(l)
    ...
    ...
print foo(10)
print foo(20)

both time reference is same

140403877687808
[10]
140403877687808
[10, 20]

while in another case:-

    def foo(a, l=[]):
        print id(l)
        ...
        ...
    print foo(10)
    print foo(20, [])

reference changes:-

>>> 
140182233489920
[10]
140182233492512
[20]

ajay_t · Answer 4 · 2014-11-17T08:17:48.890

It's because

   Default parameter values are always evaluated when, and only when, 
the “def” statement they belong to is executed.

    “def” is an executable statement in Python, and that default arguments are 
 evaluated in the “def” statement’s environment. If you execute “def” multiple times,
 it’ll create a new function object (with freshly calculated default values) each time.
 We’ll see examples of this below.

So here In your code, You are defining the list as default parameters. So it is evaluated only once when function is defined. Here come the reference of "def"

So only one object of list is created which is used multiple times whenever function is called and items get appended.

If you look the list identity then you will find function keeps returning the same object

>>> def foo(l=[]):
... l.append(1)
...return l    
>>> id(foo())
12516768
>>> id(foo())
12516768
>>> id(foo())
12516768

The way to achieve what you want to do is

def foo(a, l=None):
    if l is None:
        l = []
    #Do your stuff here with list l

python function definition: function returning local to a global scope

4 Answers4