Keyword arguments - strange behaviour?

[brian.bird]

Can anyone explain the behaviour of python when running this script?

def method(n, bits=[]): .... bits.append(n)
.... print bits
.... method(1) [1] method(2) [1, 2]

It's the same in python 1.5, 2.3 and 2.4 so it's not a bug. But I
expected the variable "bits" to be re-initialised to an empty list as
each method was called. Whenever I explain optional keyword arguments
to someone I have usually (wrongly as it turns out) said it is
equivalent to:
def method(n, bits=None): .... if bits is None:
.... bits=[]
.... bits.append(n)
.... print bits
.... method(1) [1] method(2)

[2]

Is there a good reason why these scripts are not the same? I can
understand how/why they are different, it's just not what I expected.
(It seems strange to me that the result of the first method can only be
determined if you know how many times it has already been called)

Is this behaviour what you would (should?) intuitively expect?
Thanks,

Brian

[deelan]

br********@secu retrading.com wrote:

Can anyone explain the behaviour of python when running this script? (...)
Is there a good reason why these scripts are not the same? I can
understand how/why they are different, it's just not what I expected.
(It seems strange to me that the result of the first method can only be
determined if you know how many times it has already been called)

see "python gotchas":
<http://www.ferg.org/projects/python_gotchas. html#bct_sec_5>

bye.

--
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
<#me> a foaf:Person ; foaf:nick "deelan" ;
foaf:weblog <http://www.netspyke.co m/> .

[Fredrik Lundh]

br********@secu retrading.com wrote:

Can anyone explain the behaviour of python when running this script?

the language reference has the full story:

http://www.python.org/doc/2.4/ref/function.html

"Default parameter values are evaluated when the function
definition is executed"

</F>

[Duncan Booth]

wrote:

Can anyone explain the behaviour of python when running this script?

def method(n, bits=[]): ... bits.append(n)
... print bits
... method(1) [1] method(2)

[1, 2]

It's the same in python 1.5, 2.3 and 2.4 so it's not a bug. But I
expected the variable "bits" to be re-initialised to an empty list as
each method was called. Whenever I explain optional keyword arguments
to someone I have usually (wrongly as it turns out) said it is
equivalent to:

<snipped erroneous comparison>

No, it is closer to:

# Assume you have done this earlier:
import new
def _realmethod(n, bits):
bits.append(n)
print bits

# The def is roughly equivalent to this:
_defaultArgs = ([], )
method = new.function(_r ealmethod.func_ code, globals(), 'method',
_defaultArgs)

Each time you re-execute the def you get a new set of default arguments
evaluated, but the result of the evaluation is simply a value passed in to
the function constructor.

The code object is compiled earlier then def creates a new function object
from the code object, the global dictionary, the function name, and the
default arguments (and any closure as well, but its a bit harder to
illustrate that this way).

[brian.bird]

Thanks, this makes perfect sense. The phrase which sums it up neatly is
"Default parameter values are evaluated when the function definition is
executed"

However, is there a good reason why default parameters aren't evaluated
as the function is called? (apart from efficiency and backwards
compatibility)? Is this something that's likely to stay the same in
python3.0?

I'm really looking for a neat way to do the following:

def method(a,b,opt1 =None,opt2=None ,opt3="",opt4=N one):
if opt1 is None: opt1=[]
if opt2 is None: opt2={}
if opt4 is None: opt4=[]

Python syntax is normally so neat but this just looks a mess if there
are lots of parameters.

[Fredrik Lundh]

<br********@sec uretrading.com> wrote:

However, is there a good reason why default parameters aren't evaluated
as the function is called? (apart from efficiency and backwards compatibility)?

how would you handle this case:

def function(arg=ot herfunction(val ue)):
return arg

</F>

[brian.bird]

def function(arg=ot herfunction(val ue)):
return arg

My expectation would have been that otherfunction(v alue) would be
called if (and only if) the arg keyword parameter was missing from the
function() call (ie. the optional value is evaluated the lazy way).
Also, otherfunction would be called each and every time this function()
is called without the arg keyword. (At least, I would have assumed this
before today)

Still, I can see why it's been implemented the way it has, it just
seems a shame there isn't a neat shortcut to default lots of optional
arguments to new mutable objects. And since I'm not the only one to
fall into this trap it makes me wonder why the default behaviour isn't
made to be what most people seem to expect?

[Fredrik Lundh]

<br********@sec uretrading.com> wrote:

def function(arg=ot herfunction(val ue)):
return arg

My expectation would have been that otherfunction(v alue) would be
called if (and only if) the arg keyword parameter was missing from the
function() call (ie. the optional value is evaluated the lazy way).

what otherfunction? what value?

</F>

[harold fellermann]

Hi,

I cannot see any strange behavior. this code works exacly as you and I
suspect:

def otherfunction(x ) : .... return x
.... def function(arg=ot herfunction(5)) : .... return arg
.... function(3) 3 function()

5

Or is this not what you excepted?

- harold -

On 21.12.2004, at 15:47, br********@secu retrading.com wrote:
def function(arg=ot herfunction(val ue)):
return arg

My expectation would have been that otherfunction(v alue) would be
called if (and only if) the arg keyword parameter was missing from the
function() call (ie. the optional value is evaluated the lazy way).
Also, otherfunction would be called each and every time this function()
is called without the arg keyword. (At least, I would have assumed this
before today)

Still, I can see why it's been implemented the way it has, it just
seems a shame there isn't a neat shortcut to default lots of optional
arguments to new mutable objects. And since I'm not the only one to
fall into this trap it makes me wonder why the default behaviour isn't
made to be what most people seem to expect?

--
http://mail.python.org/mailman/listinfo/python-list

--
Freunde, nur Mut,
Lächelt und sprecht:
Die Menschen sind gut --
Bloß die Leute sind schlecht.
-- Erich Kästner

[Steve Holden]

harold fellermann wrote:

Hi,

I cannot see any strange behavior. this code works exacly as you and I
suspect:

>>> def otherfunction(x ) : .... return x
.... >>> def function(arg=ot herfunction(5)) : .... return arg
.... >>> function(3) 3 >>> function()

5

Or is this not what you excepted?

Channelling the effbot, I think he was asking what namespace context you
expected the expression "arg=otherfunct ion(x)" to be evaluated in when
it's used at the time of a function call to dynamically create a new
default value for arg.

regards
Steve
--
Steve Holden http://www.holdenweb.com/
Python Web Programming http://pydish.holdenweb.com/
Holden Web LLC [phone] [phone]