如何将空参数传递给python函数？

Question

Here is the working code:

def g(y=10):
    return y**2

def f(x,y=10):
    return x*g(y)

print(f(5)) #->500

However, let's suppose we don't want to remember and copy a default value of keyword parameter y to the definition of external function (especially if there are several layers of external functions). In the above example it means that we want to use parameter, already defined in g .

One way to do that:

def f(x,y=None):
    if y==None: return x*g()
    else: return x*g(y)

But is there a cleaner way to do the same? Something like:

def f(x,y=empty()):
    return x*g(y)

Answer 1

This is possible :

def g(y=10):
    return y**2

def f(x, y=g.__defaults__[0]):
    return x * g(y)

But it is arguably less clear than what you had originally (defaulting y to None ).

An option which doesn't restrict the definition order of f and g , and should remain working if the function default of g gets changed dynamically:

def f(x, y=None):
    kwargs = {}
    if y is None:
        kwargs['y'] = y
    return x * g(**kwargs)

Answer 2

Interesting question! Here's another possibility, however this requires handing in the second parameter as a named parameter.

>>> def g(y=10):
...     return y**2
... 
>>> def f(x, **kwargs):
...     return x * g(**kwargs)
... 
>>> f(5)
500
>>> f(5, y=0)
0

Answer 3

A limitation of signatures such as def f(x, y=None) or def f(x, **kwargs) is that readers have to dig into source code or documentation to find out what's going on with y . Stick to something simple and straightforward:

DEFAULT_Y = 10
def g(y=DEFAULT_Y): ...
def f(x, y=DEFAULT_Y): ...

Answer 4

I'd like to start by saying if the arguments were keyword only this would be so easy:

def f(*, x="x", y= "y",z="z"):
    print(x,y,z)

def g(*, x,y,z):
    print(x,y,z,"from g!!")

if g.__kwdefaults__ is None: #completely override defaults
    g.__kwdefaults__ = f.__kwdefaults__
else: #if there are already some defaults then update
    g.__kwdefaults__.update(f.__kedefaults__)

g()

if you are using positional arguments it isn't quite as easy although your example is one of the specific cases that works the same way:

def g(y=10): #last argument is y
    return y**2

def f(x,y): #last argument is y
    return x*g(y)
f.__defaults__ = g.__defaults__ #copies the end of the defaults to f

print(f(5)) #->500

But this is a very specific case:

1. The arguments to inherit the defaults must be in the same order as the original.
2. There must not be any positional arguments after the ones with inherited defaults
3. There must not be any other arguments with default values (or they get overridden)

The generic solution requires quite a bit of code but allows any signature to be merged into another, for example:

def f(x,y,z=0,reverse=True):
    pass

@copy_defaults(f)
def g(a,b, #arguments for g
      x,y,z, #arguments to forward to f
      c=None, d="test", #some optional arguments for g
      *,reverse): #only take reverse as a keyword
    pass

>>> inspect.signature(g)
<Signature (a, b, x, y, z=0, c=None, d='test', *, reverse=True)>

This can be achieved with the following code (I can't find a simpler way to do it that works with above case)

import inspect

def copy_defaults(original_f):
    "creates wrapper for DefaultArgs(original_f).copy_defaults(dest_f)"
    def wrapper(dest_f):
        return DefaultArgs(original_f).copy_defaults(dest_f)
    return wrapper

class DefaultArgs(dict):
    def __init__(self,func):
        spec = inspect.getfullargspec(func)
        if spec.defaults:
            dict.__init__(self,
                          zip(reversed(spec.args),
                              reversed(spec.defaults)
                          ))
        else:
            dict.__init__(self) #I'm not sure this is necessary
        if spec.kwonlydefaults:
            self.update(spec.kwonlydefaults)

    def get_kwdefaults(self,keywords):
        return {k:v for k,v in self.items() if k in keywords}

    def gen_pos_defaults(self,args,defaults=None):
        if defaults is None:
            defaults = ()
        found_default = False
        for i,arg in enumerate(args,start=len(defaults)-len(args)):
            if arg in self:
                yield self[arg]
                found_default = True
            elif i>=0:
                yield defaults[i]
            elif found_default: #if an argument does not have a default but is after one that does
                raise TypeError("non-default argument %r follows default argument"%arg)

    def copy_defaults(self,func):
        spec = inspect.getfullargspec(func)
        new_kwargs = self.get_kwdefaults(spec.kwonlyargs)
        if func.__kwdefaults__ is not None:
            func.__kwdefaults__.update(new_kwargs)
        else:
            func.__kwdefaults__ = new_kwargs

        func.__defaults__ = tuple(self.gen_pos_defaults(spec.args,spec.defaults))
        return func

Answer 5

If you can modify g , then this works:

def g(y=None):
    if y is None:
        y = 10
    return y**2

def f(x,y=None):
    return x*g(y)