e-mail address change (was Re: [Tutor] python's default argument value handling in functions - weird syntax? problem grappling with the concept)

[Bob Gailer]

At 01:14 PM 2/9/2005, Jeffrey Lim wrote:
hey folks, i'm a relative newbie to python itself, and I am currently
learning by making my way through the tutorial found within the docs
of 2.4 (http://www.python.org/doc/2.4/tut/tut.html).
I am currently having a problem dealing with the concept of the
"default argument value" in python functions, and just how python
handles this.
Now http://www.python.org/doc/2.4/tut/node6.html#SECTION006710000000000000000
makes the statement that "the default value is evaluated only once".
While that is fine, what I don't really get is how the solution given
can even make sense - either syntactically, or conceptually.
First of all, let me quote what the doc says:
===========
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]
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
========
This leads me to at first conclude several things:
1. 'L' in this case (or by extension, all function arguments for which
a default is given in the function definition) is "static" (see 'C'
language definition). This is my conclusion, seeing as how 'L' can
seem to retain its value even though it has gone out of scope after
the 'f' function returns.
Correct me if i'm wrong here, guys.
2. (*Now this is where I start to get confused. I think the best way
to illustrate how I am having problems is to illustrate with a few
examples. The basic problem that I am having is, "Which L is which
L?")
My examples...
Example 1
>>> def f(a,L=[]):
...     if L==[5]:
...       print 'L==[5] caught'
...       print L
...       print 'resetting L...'
...       L=[]
...     L.append(a)
...     return L
...
>>> f(5)
[5]
>>> f(5)
L==[5] caught
[5]
resetting L...
[5]
>>> f(2)
L==[5] caught
[5]
resetting L...
[2]
That works as expected. I assume you are happy with the results.
Example 2
>>> def f(a,L=None):
...     if L==[5]:
...             print 'caught, printing, resetting'
...             print L
...             L=[]
...     else:
...             L=[]
...     L.append(a)
...     return L
...
>>> f(5)
[5]
>>> f(6)
[6]
>>> f(6)
That also works as expected. I assume you are happy with the results.
So when the default value for 'L' is an empty list, the test
condition, _once triggered_, *always* catches?
No. What leads you to think that is happening? This code empties the list 
each time you invoke it.

But when the default value for 'L' is none, the 'if' never catches?
How is this possible?
Or even consider the example given -
def f(a, L=None):
    if L is None:
        L = []
    L.append(a)
    return L
How is 'L == None' even possible all the time, given that for
def f(a, L=[]):
    L.append(a)
    return L
, L isn't even [] except for the first call to 'f'?
From the 1st reference you cited above: 'The default values are evaluated 
at the point of function definition"

Bob Gailer
mailto:[EMAIL PROTECTED]
303 442 2625 home
720 938 2625 cell 

_______________________________________________
Tutor maillist  -  Tutor@python.org
http://mail.python.org/mailman/listinfo/tutor