Recipe20.1.Getting Fresh Default Values at Each Function Call

Recipe 20.1. Getting Fresh Default Values at Each Function Call

Credit: Sean Ross

Problem

Python computes the default values for a function's optional arguments just once, when the function's def statement executes. However, for some of your functions, you'd like to ensure that the default values are fresh ones (i.e., new and independent copies) each time a function gets called.

Solution

A Python 2.4 decorator offers an elegant solution, and, with a slightly less terse syntax, it's a solution you can apply in version 2.3 too:

import copy def freshdefaults(f):     "a decorator to wrap f and keep its default values fresh between calls"     fdefaults = f.func_defaults     def refresher(*args, **kwds):         f.func_defaults = deepcopy(fdefaults)         return f(*args, **kwds)     # in 2.4, only: refresher._ _name_ _ = f._ _name_ _     return refresher # usage as a decorator, in python 2.4: @freshdefaults def packitem(item, pkg=[  ]):     pkg.append(item)     return pkg # usage in python 2.3: after the function definition, explicitly assign: # f = freshdefaults(f)

Discussion

A function's default values are evaluated once, and only once, at the time the function is defined (i.e., when the def statement executes). Beginning Python programmers are sometimes surprised by this fact; they try to use mutable default values and yet expect that the values will somehow be regenerated afresh each time they're needed.

Recommended Python practice is to not use mutable default values. Instead, you should use idioms such as:

def packitem(item, pkg=None):     if pkg is None:         pkg = [  ]     pkg.append(item)     return pkg

The freshdefaults decorator presented in this recipe provides another way to accomplish the same task. It eliminates the need to set as your default value anything but the value you intend that optional argument to have by default. In particular, you don't have to use None as the default value, rather than (say) square brackets [ ], as you do in the recommended idiom.

freshdefaults also removes the need to test each argument against the stand-in value (e.g., None) before assigning the intended value: this could be an important simplification in your code, where your functions need to have several optional arguments with mutable default values, as long as all of those default values can be deep-copied.

On the other hand, the implementation of freshdefaults needs several reasonably advanced concepts: decorators, closures, function attributes, and deep copying. All in all, this implementation is no doubt more difficult to explain to beginning Python programmers than the recommended idiom. Therefore, this recipe cannot really be recommended to beginners. However, advanced Pythonistas may find it useful.

Setting the Name of a Function

If an outer function just returns an inner function (often a closure), the name of the returned function object is fixed, which can be confusing when the name is shown during introspection or debugging:

>>> def make_adder(addend): ...   def adder(augend): return augend+addend ...   return adder ... >>> plus100 = make_adder(100) >>> plus_23 = make_adder(23) >>> print plus100(1000), plus_23(1000) 1100 1023 >>> print plus100, plus_23 <function adder at 0x386530> <function adder at 0x3825f0>

As you see, the functionality of plus100 and plus_23 is correct (they add 100 and 23 to their argument, respectively). Confusingly, however, their names are both 'adder', even though they are different functions. In Python 2.4, you can solve the problem by setting the _ _name_ _ attribute of the inner function right after the end of the inner function's def statement, and before the return statement from the outer function:

def make_adder(addend):     def adder(augend):         return augend+addend     adder._ _name_ _ = 'add_%s' % (addend,)     return adder

With this change in make_adder, the previous snippet would now produce more useful output:

>>> print plus100, plus_23 <function add_100 at 0x386530> <function add_23 at 0x3825f0>

Unfortunately, in Python 2.3, you cannot assign to the _ _name_ _ attribute of a function object; in that release, the attribute is read-only. If you want to obtain the same effect in Python 2.3, you must follow a more roundabout route, making and returning a new function object that differs from the other only in name:

import new def make_adder(addend):   def adder(augend): return augend+addend   return new.function(adder.func_code, adder.func_globals, 'add_%s' % (addend,),                       adder.func_defaults, adder.func_closure)

Recipe20.1.Getting Fresh Default Values at Each Function Call