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 y:

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 y=7

If you need to remove default arguments I see two ways:

1. Store original function somewhere

   oldF = f
   f = functools.partial(f, y = 42)
   //work with changed f
   f = oldF //restore
   

2. use partial.func

   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 *, *args, **kwargs—anything after that goes into the __kwdefaults__ dict instead). f.__defaults = (4, 5) will set the defaults to y and z to 4 and 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__)

Here, the 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.

yes, you can accomplish this by modifying the function's func.__defaults__ tuple

that attribute is a tuple of the default values for each argument of the function.

for example, to make pandas.read_csv always use sep='\t', you could do:

import inspect

import pandas as pd

default_args = inspect.getfullargspec(pd.read_csv).args
default_arg_values = list(pd.read_csv.__defaults__)
default_arg_values[default_args.index("sep")] = '\t'
pd.read_csv.__defaults__ = tuple(default_arg_values)

use 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