Python Default Arguments Evaluation

Question

I was reading the python tutorial from Python Documentation Release 2.7.10 and I came across something like this.

Code

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

print fun1(1)
print fun1(2)
print fun1(3)

def fun2(a,L = None):
    if L is None:
        L=[]
    L.append(a)
    return L

print fun2(1)
print fun2(2)
print fun2(3)

Output

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

Process finished with exit code 0

If the L=[] in the first function fun1() is getting called only once , the output of fun1()is fine. But then why L=None is getting called every time in fun2().

*"why `L=None` is not getting called every time"* – I don't know what you're trying to say with this. — deceze, Sep 01 '15 at 08:20
I am assuming that `L=None` is getting called/executed every time. That's why the condition `if L is None` is true every time in the second function `fun2()`. — Nitin Pandey, Sep 01 '15 at 08:23
Default arguments are evaluated on function declaration. Empty list is mutable, so in each function call you are editing same list. Appending to it does not create new object. With None, list is created in function body. Each time new list is returned from function. — Łukasz Rogalski, Sep 01 '15 at 08:24

score 4 · Answer 1 · answered Sep 01 '15 at 08:28

L=[] in the function declaration makes Python essentially do this:

this function has a parameter named L
its default argument is [], let's set this particular [] aside and use it anytime there's no parameter passed for L
every time the function is called, create a variable L, and assign it either the passed parameter or the value we set aside earlier

So, the [] part is getting executed once, which creates a list object, which is set aside and kept around, which is why it accumulates changes if you modify it. Exactly the same thing happens with None, however None is not being modified nor is it mutable to begin with, so you're not seeing any weird side effects. None is still only being "executed" once, and that particular None value is set aside just as the list was, it's just that you're not doing anything to the None value itself.

But I am changing the `L=None` to `L=[]` inside the `if ` condition in `fun2()`. Why is this assignment/change not permanent or visible to other subsequent function calls. — Nitin Pandey, Sep 01 '15 at 09:30
Again: *every time the function is called, the __variable__ `L` is created and assigned a value*. ***The value `[]`*** is permanent, not its association to `L`. ***The value `[]`*** stores things you `.append` to it, not `L`. The permanent object `[]` in memory is something different than the variable `L` pointing to it. — deceze, Sep 01 '15 at 09:33

skyking · Accepted Answer · 2015-09-01T08:34:10.880

When you define a function the values of the default arguments get evaluated, but the body of the function only get compiled. You can examine the result of the function definition via attributes. Theres a __defaults__ attribute containing the defaults and __code__ attribute containing the body (so these are created when the function is defined).

What's happening in the second example is that None do get evaluated at definition (it evaluates to None duh!), but the code that conditionally assigns [] to L only gets compiled and is run each time (the condition passes).

score 1 · Answer 3 · answered Sep 01 '15 at 08:25

1

default arguments are evaluated only once. In fun1 you have the same list which you keep adding to. In fun2 you assign a new [] to the parameter and then append to it. As any assignment, its scope will be limited to the block it occurred in.

answered Sep 01 '15 at 08:25

Mureinik

297,002
52
306
350

Python Default Arguments Evaluation

3 Answers3

Linked