[ Is it possible to change a function's default parameters in Python? ]
In Python, is it possible to redefine the default parameters of a function at runtime?
I defined a function with 3 parameters here:
def multiplyNumbers(x,y,z): return x*y*z print(multiplyNumbers(x=2,y=3,z=3))
Next, I tried (unsuccessfully) to set the default parameter value for y, and then I tried calling the function without the parameter
multiplyNumbers.y = 2; print(multiplyNumbers(x=3, z=3))
But the following error was produced, since the default value of
y was not set correctly:
TypeError: multiplyNumbers() missing 1 required positional argument: 'y'
Is it possible to redefine the default parameters of a function at runtime, as I'm attempting to do here?
Just use functools.partial
multiplyNumbers = functools.partial(multiplyNumbers, y = 42)
One problem here: you will not be able to call it as
multiplyNumbers(5, 7, 9); you should manually say
If you need to remove default arguments I see two ways:
Store original function somewhere
oldF = f f = functools.partial(f, y = 42) //work with changed f f = oldF //restore
f = f.func //go to previous version.
Technically, it is possible to do what you ask… but it's not a good idea. RiaD's answer is the Pythonic way to do this.
In Python 3:
>>> def f(x=1, y=2, z=3): ... print(x, y, z) >>> f() 1 2 3 >>> f.__defaults__ = (4, 5, 6) 4 5 6
As with everything else that's under the covers and hard to find in the docs, the
inspect module chart is the best place to look for function attributes.
The details are slightly different in Python 2, but the idea is the same. (Just change the pulldown at the top left of the docs page from 3.3 to 2.7.)
If you're wondering how Python knows which defaults go with which arguments when it's just got a tuple… it just counts backward from the end (or the first of
**kwargs—anything after that goes into the
__kwdefaults__ dict instead).
f.__defaults = (4, 5) will set the defaults to
5, and with default for
x. That works because you can't have non-defaulted parameters after defaulted parameters.
There are some cases where this won't work, but even then, you can immutably copy it to a new function with different defaults:
>>> f2 = types.FunctionType(f.__code__, f.__globals__, f.__name__, ... (4, 5, 6), f.__closure__)
types module documentation doesn't really explain anything, but
help(types.FunctionType) in the interactive interpreter shows the params you need.
The only case you can't handle is a builtin function. But they generally don't have actual defaults anyway; instead, they fake something similar in the C API.
func_defaults as in
def myfun(a=3): return a myfun.func_defaults = (4,) b = myfun() assert b == 4
check the docs for func_defaults here
UPDATE: looking at RiaD's response I think I was too literal with mine. I don't know the context from where you're asking this question but in general (and following the Zen of Python) I believe working with partial applications is a better option than redefining a function's defaults arguments