Bug in python!? persistent value of an optional parameter in function!

[C Barr Leigh]

Help! Have I found a serious bug?
This seems like highly undesired behaviour to me. From the program
below, I get output:

call1: ['sdf']
call2: ['Set within test for call2']
call3: ['Set within test for call2']

instead of what I should get,

call1: ['sdf']
call2: ['Set within test for call2']
call3: ['Set within test for call3']

I'm using Python 2.4.4c1 (#2, Oct 11 2006, 21:51:02). The code is
below.


#!/usr/bin/python

def testPersistence(anarg,twooption=[]):
#print anarg
if not twooption:
twooption.append('Set within test for '+anarg)
print anarg +': '+str(twooption)

testPersistence('call1',twooption=['sdf']);
testPersistence('call2');
testPersistence('call3');

 

[Paul Rubin]

Help! Have I found a serious bug?
This seems like highly undesired behaviour to me. From the program
below, I get output:

It is intentional, not a bug, see the docs. Whether it's desirable is
a different question.

 

[Gabriel Genellina]

Help! Have I found a serious bug?

Not at all! This is by design.

def testPersistence(anarg,twooption=[]):
#print anarg
if not twooption:
twooption.append('Set within test for '+anarg)

See
http://effbot.org/pyfaq/why-are-default-values-shared-between-objects.htm

 

[John Nagle]

It is intentional, not a bug, see the docs. Whether it's desirable is
a different question.

True. It would make sense to disallow mutable values as
initial values for optional arguments. The present behavior
is silly.

John Nagle

 

[Paul Rubin]

True. It would make sense to disallow mutable values as
initial values for optional arguments. The present behavior is silly.

That would be the worst of both worlds. The main alternative to the
present behavior is re-computing the default value every time the
function is entered.

 

[George Sakkis]

True. It would make sense to disallow mutable values as
initial values for optional arguments. The present behavior
is silly.

1. If you'd given it a little more thought than it took you to write
this, you would perhaps realize that it is in general impossible to
determine automatically whether an arbitrary object is mutable or
not.

2. Even if you could determine it, it would be overly restrictive to
disallow all mutable values from defaults. The fact that an object is
mutable doesn't mean that the function will try to mutate it:

def paintWall(ind, colormap={1:'red', 2:'blue', 5:'green'}):
print "Let's paint the wall %s" % colormap[ind]


George

 

[George Sakkis]

That would be the worst of both worlds. The main alternative to the
present behavior is re-computing the default value every time the
function is entered.

One can do this is today's Python if he's so inclined, albeit with a
more verbose syntax: http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/502206

George

 

[Steven D'Aprano]

True. It would make sense to disallow mutable values as
initial values for optional arguments. The present behavior
is silly.

It's just *different*, not silly.

It's also quite useful in some circumstances, e.g. cheap caching without
using a global variable.

def factorial(n, _cache={}):
try:
return _cache[n]
except KeyError:
# fall back to slow calculation
if n <= 1:
result = 1
else:
result = factorial(n-1)*n
_cache[n] = result
return result

There are other ways of implementing caches, but this is quick and easy
and works well for many functions.

 

[Paul Rubin]

def factorial(n, _cache={}):
try:
return _cache[n]
except KeyError:
There are other ways of implementing caches, but this is quick and easy
and works well for many functions.

I like this better (examples are untested):

def factorial(n):
try:
return factorial.cache[n]
except KeyError: pass
...
factorial.cache = {}

you could even use a decorator:

def memoize(f): # memoize a 1-arg function
f.cache = {}
def g(f,x):
if x in f.cache: return f.cache[x]
return f.cache.setdefault(x, f(x))
return functools.partial(g,f)
...

@memoize
def factorial(n):
return 1 if n==0 else n*factorial(n-1)

 

[C Barr Leigh]

Oh, oops! Of course... A great and sensible feature if you're
expecting it.
Thanks very much, everyone, for the links and discussion!

Chris

 

[Bjoern Schliessmann]

True. It would make sense to disallow mutable values as
initial values for optional arguments. The present behavior
is silly.

Why? You're free to only use immutables.

Regards,


Björn

 

[Ayaz Ahmed Khan]

"Gabriel Genellina" typed:

See
http://effbot.org/pyfaq/why-are-default-values-shared-between-objects.htm

Thanks for the link, Gabriel. I didn't know about this.

--
Ayaz Ahmed Khan

Falling in love makes smoking pot all day look like the ultimate in
restraint.
-- Dave Sim, author of "Cerebus".

 

[Bruno Desthuilliers]

C Barr Leigh a écrit :

Help! Have I found a serious bug?

No. This is a FAQ. Default arguments of functions are evaled only once -
when the def statement is eval'd and the function object constructed.

This seems like highly undesired behaviour to me.

Possibly, but this is unlikely to change in a near future, so you'd
better get used to it. If you want mutable objects as default values for
functions, the idiom is:

def some_func(default=None):
if default is None:
default = []
# code here

HTH