避免 Python 中默认参数中的代码重复

Question

考虑一个带有默认参数的典型函数：

def f(accuracy=1e-3, nstep=10):
    ...

这是紧凑且易于理解的。但是，如果我们有另一个函数g 将调用f，并且我们想将g 的一些参数传递给f，该怎么办？这样做的自然方式是：

def g(accuracy=1e-3, nstep=10):
    f(accuracy, nstep)
    ...

这种做事方式的问题是可选参数的默认值会重复。通常在像这样传播默认参数时，希望上层函数 (g) 中的默认值与下层函数 (f) 中的默认值相同，因此任何时候 f 中的默认值更改都需要遍历所有调用它并更新它们将传播到 f 的任何参数的默认值的函数。

另一种方法是使用占位符参数，并在函数内填充其值：

def f(accuracy=None, nstep=None):
    if accuracy is None: accuracy = 1e-3
    if nstep is None: nstep=10
    ...
def g(accuracy=None, nstep=None):
    f(accuracy, nstep)
    ...

现在调用函数不需要知道f 的默认值是什么。但是f 接口现在有点繁琐，不太清晰。这是没有显式默认参数支持的语言中的典型方法，例如 fortran 或 javascript。但是，如果在 python 中以这种方式做所有事情，那么就会放弃该语言的大部分默认参数支持。

还有比这两个更好的方法吗？这样做的标准、pythonic 方式是什么？

Answer 1

我认为程序范式将您的视野缩小到该问题。以下是我使用其他 Python 功能找到的一些解决方案。

面向对象编程

您正在使用相同的参数子集调用f() 和g()——这很好地暗示了这些参数代表相同的实体。为什么不让它成为一个对象呢？

class FG:
    def __init__(self, accuracy=1e-3, nstep=10):
        self.accuracy = accuracy
        self.nstep = nstep

    def f(self):
        print ('f', self.accuracy, self.nstep)

    def g(self):
        self.f()
        print ('g', self.accuracy, self.nstep)

FG().f()
FG(1e-5).g()
FG(nstep=20).g()

函数式编程

您可以将f() 转换为高阶函数——例如：

from functools import partial

def g(accuracy, nstep):
    print ('g', accuracy, nstep)

def f(accuracy=1e-3, nstep=10):
    g(accuracy, nstep)
    print ('f', accuracy, nstep)

def fg(func, accuracy=1e-3, nstep=10):
    return partial(func, accuracy=accuracy, nstep=nstep)

fg(g)()
fg(f, 2e-5)()
fg(f, nstep=32)()

但这也是一种棘手的方法——f() 和 g() 调用在这里交换。可能有更好的方法来做到这一点——即带有回调的管道，我对 FP 不是很好:(

动态与内省

这是一种复杂得多的方法，它需要深入研究 CPython 内部，但既然 CPython 允许这样做，为什么不使用它呢？

这是一个通过__defaults__成员更新默认值的装饰器：

class use_defaults:
    def __init__(self, deflt_func):
        self.deflt_func = deflt_func

    def __call__(self, func):
        defltargs = dict(zip(getargspec(self.deflt_func).args, 
                            getargspec(self.deflt_func).defaults))

        defaults = (list(func.__defaults__) 
                    if func.__defaults__ is not None 
                    else [])

        func_args = reversed(getargspec(func).args[:-len(defaults)])

        for func_arg in func_args:
            if func_arg not in defltargs:
                # Default arguments doesn't allow gaps, ignore rest
                break
            defaults.insert(0, defltargs[func_arg])

        # Update list of default arguments
        func.__defaults__ = tuple(defaults)

        return func

def f(accuracy=1e-3, nstep=10, b = 'bbb'):
    print ('f', accuracy, nstep, b)

@use_defaults(f)
def g(first, accuracy, nstep, a = 'aaa'):
    f(accuracy, nstep)
    print ('g', first, accuracy, nstep, a)

g(True)
g(False, 2e-5)
g(True, nstep=32)

但是，这排除了具有单独 __kwdefaults__ 的仅关键字参数，并且可能会破坏 use_defaults 装饰器背后的逻辑。

您也可以使用包装器在运行时添加参数，但这可能会降低性能。

Answer 2

与@unutbu 相吻合：

如果您使用的是包结构：

mypackage
|
+- __init__.py
|
+- fmod.py
|
+- gmod.py
|
...

然后在__init__.py 中按照@unutbu 的建议输入常量：

ACCURACY = 1e-3
NSTEP = 10
__all__ = ['ACCURACY', 'NSTEP']

然后在fmod.py

from mypackage import *
def f(accuracy=ACCURACY, nstep=NSTEP):
    ...

和gmod.py 和任何其他模块导入您的常量。

from mypackage import *
def g(accuracy=ACCURACY, nstep=NSTEP):
    f(accuracy, nstep)
    ...

或者，如果您不使用包，只需创建一个名为 myconstants.py 的模块，然后执行与 __init__.py 完全相同的操作，只是不是从 mypackage 导入，而是从 myconstants 导入。

这种风格的一个优点是，如果稍后您想从文件中读取常量（或作为函数的参数）假设它存在，您可以将代码放入__init__.py 或myconstants.py 来执行此操作。

Answer 3

定义全局常量：

ACCURACY = 1e-3
NSTEP = 10

def f(accuracy=ACCURACY, nstep=NSTEP):
    ...

def g(accuracy=ACCURACY, nstep=NSTEP):
    f(accuracy, nstep)

---

如果f 和g 定义在不同的模块中，那么你也可以创建一个constants.py 模块：

ACCURACY = 1e-3
NSTEP = 10

然后定义f：

from constants import ACCURACY, NSTEP
def f(accuracy=ACCURACY, nstep=NSTEP):
    ...

g 也是如此。

Answer 4

我最喜欢的，kwargs！

def f(**kwargs):
    kwargs.get('accuracy', 1e-3)
    ..

def g(**kwargs):
    f(**kwargs)

当然，您可以随意使用上述常量。