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

[Fuzzyman]

Steven Bethard wrote:

Fuzzyman wrote:

Steven Bethard wrote:
>
>So, one of my really common use cases that takes advantage of the
>fact that default parameters are evaluated at function definition
>time:
>
>def foo(bar, baz, matcher=re.comp ile(r'...')):
> ...
> text = matcher.sub(r'. ..', text)
> ... Sure.. but you also gave an example of an alternative that was complex,
Interesting. I would have thought that my example was pretty simple. Maybe it would be helpful to generalize it to:

def foo(bar, baz, spam=badger(x, y, z)):
...

All it does is use a default value that was produced by a function call. I'm surprised you haven't run into this situation before...

Of course, what is complex or simple is a matter of personal opinion. I use this pattern so often that it's quite simple to me, but I guess I can understand that if you don't use such a pattern, it might seem
foreign to you.

Steve

Hello Steve,

It wasn't that part of the example that I thought was over complex.
(although it's not a 'pattern' I use often). You suggested that if we
had dynamic evaluation of default values, you would have to replace it
with :

class foo(object):
matcher=re.comp ile(r'...')
def __new__(self, bar, baz, matcher=None):
if matcher is None:
matcher = self.matcher
...
text = matcher.sub(r'. ..', text)
...

Now that I thought was over complex... when all you wanted to do was
put a constant into your default value !

Having said that I see Steve's point about not knowing the namespace
when the function will be called.
Regards,

Fuzzy
http://www.voidspace.org.uk/python/index.shtml

[Alex Martelli]

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

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.

There's a decorator for that in the Cookbook (sorry, don't recall the
recipe number, but, it's on the site, and it got into the 2nd edition
which we're still expecting to have on paper at PyCon) -- basically
wrapping a function with a wrapper that does a copy.deepcopy on the
defaults values at each call (efficiency of course goes down the drain,
but you _did_ say "apart from efficiency"!-).
Alex

[Alex Martelli]

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

the default params are evaluated at the definition. However, I still
can't give a nice looking solution on how to re-write a function to
have empty mutable values as default arguments: eg.

def method(a,b,opt1 =[],opt2=None,opt3 ="",opt4={})

How could I re-write this (especially if there are perhaps 20 optional
parameters,any number of which may have mutable defaults) without
writing 20 "if opt1 is None: opt1=[]" statements?

I don't have the recipe I mentioned at hand, but what about:

def makebrianhappy( f):
saved_defaults = f.func_defaults
def with_fresh_defa ults(*a, **k):
f.func_defaults = copy.deepcopy(s aved_defaults)
return f(*a, **k)
with_fresh_defa ults.__name__ = f.__name__
return with_fresh_defa ults

@ makebrianhappy
def method(a, b, opt1=[], opt2=None, opt3="", opt4={}):
...

I've added spaces after commas to make ME happy too (lack of such spaces
is my least favourite Python irritation;-), but I guess the semantics of
this (UNTESTED) code would work even without that;-).
Alex

[Steven Bethard]

Fuzzyman wrote:

It wasn't that part of the example that I thought was over complex.
(although it's not a 'pattern' I use often). You suggested that if we
had dynamic evaluation of default values, you would have to replace it
with :

>class foo(object):
> matcher=re.comp ile(r'...')
> def __new__(self, bar, baz, matcher=None):
> if matcher is None:
> matcher = self.matcher
> ...
> text = matcher.sub(r'. ..', text)
> ...

Now that I thought was over complex... when all you wanted to do was
put a constant into your default value !

Ahh. Yeah, the thing above is a bit complex, but it keeps the same
namespaces -- matcher is only available to foo, not the enclosing
class/module. Point taken of course. ;)

Steve

[brian.bird]

Thanks. In case anyone else is looking, the recipe is at:
http://aspn.activestate.com/ASPN/Coo.../Recipe/303440

(which also shows how to make it work with python2.3 and below since
they don't support decorators)

Brian