468,278 Members | 1,566 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 468,278 developers. It's quick & easy.

[Novice] Default argument value in function definition

From the Python's tutorial, about default argument values:

<quote>
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]

If you don't want the default to be shared between subsequent calls, you can
write the function like this instead:
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
</quote>

I can't imagine how subsequent calls to f can share the same value for L.
The tutorial says that a new symbol table for the variables inside of the
function is created each time the function is called, and I would say the
symbol table is destructed when the function finishes execution.

How is the value of L conserved between funtion calls?
Can someone explain the mechanism to me?

Thanks,
Tito
Jul 18 '05 #1
3 2650
Default values that are mutable types are evaluated
at definition time not execution time. That means
L is set to empty list when Python parses function
and it lives outside the function definition. It
is rather 'different' but I can assure you that is
how it works and it can sometimes bite programmers
new to Python that overlook the docs you refer to.

HTH,
Larry Bates
Syscon, Inc.
"Tito" <ti***************************@inicia.es> wrote in message
news:2l************@uni-berlin.de...
From the Python's tutorial, about default argument values:

<quote>
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]

If you don't want the default to be shared between subsequent calls, you can write the function like this instead:
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
</quote>

I can't imagine how subsequent calls to f can share the same value for L.
The tutorial says that a new symbol table for the variables inside of the
function is created each time the function is called, and I would say the
symbol table is destructed when the function finishes execution.

How is the value of L conserved between funtion calls?
Can someone explain the mechanism to me?

Thanks,
Tito

Jul 18 '05 #2
Tito wrote:
How is the value of L conserved between funtion calls?
Can someone explain the mechanism to me?


A function is just a callable object. Its default arguments are stored as a
tuple in the func_defaults attribute. You can easily experiment with these
kind of things in the interpreter:
def f(a, items=[]): .... items.append(a)
.... f(1)
f(2)
f(3)
f.func_defaults ([1, 2, 3],) f(4)
f.func_defaults ([1, 2, 3, 4],)


Peter

Jul 18 '05 #3
Thanks to you both for your explanation.

Tito
Jul 18 '05 #4

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

26 posts views Thread by Alex Panayotopoulos | last post: by
3 posts views Thread by Frank Bechmann | last post: by
5 posts views Thread by Dave Vandervies | last post: by
3 posts views Thread by Capstar | last post: by
5 posts views Thread by netvaibhav | last post: by
43 posts views Thread by kenneth | last post: by
reply views Thread by NPC403 | last post: by
reply views Thread by zattat | last post: by
1 post views Thread by MrBee | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.