如何冻结多个相关类方法的某些参数

Question

最好的方法是采用一组函数，这些函数使用一些常用的参数名（假定表示相同的东西），并生成一个包含这些函数的对象，但某些关键参数值是固定的，或者至少它们的默认值是固定的。你知道吗

如果我想要一组函数来处理由一组属性定义的特定数据，我通常会使用一个类，提供必须在__init__中设置的属性。你知道吗

但有时从函数开始更有意义，或者你没有选择，因为你在使用别人的代码。但是，您希望能够方便地修复某些参数的值，并且在操作时不必重复指定这些值，这很无聊而且容易出错。这是一种干的。你知道吗

如果你有一个函数，你只需要使用functools.partial。但是当你有一大堆函数的时候，有什么好的方法可以做到这一点呢。你知道吗

下面是一个如何使用一个参数的示例：

import inspect
from functools import partial

def mk_func_uses_arg_filt(argname):
    def func_uses_arg(obj):
        if callable(obj):
            try:
                if argname in inspect.signature(obj).parameters:
                    return True
            except ValueError:  # some functions don't have signatures (!?!)
                pass
        return False
    return func_uses_arg

class FixedArgFuncs(object):
    def __init__(self, argname, argval, funcs, only_if_func_uses_arg=True):
        func_uses_arg = mk_func_uses_arg_filt(argname)
        for func in funcs:
            if func_uses_arg(func):
                setattr(self, func.__name__, partial(func, **{argname: argval}))
            elif not only_if_func_uses_arg:
                setattr(self, func.__name__, func)

下面是一个使用all的示例操作系统路径具有“path”参数的函数（我们将修复到本地主文件夹）。你知道吗

import os.path
faf = FixedArgFuncs(argname='path', argval=os.path.expanduser('~'), 
                    funcs=filter(callable, os.path.__dict__.values()))
assert faf.exists() == True
assert faf.isfile() == False
print(list(faf.__dict__.keys()))

给了我 ['exists', 'isfile', '_get_sep', 'islink', 'lexists', 'ismount', 'expanduser', 'expandvars', 'normpath', 'abspath', '_joinrealpath', 'relpath']

这并不是完全令人满意的，因为（1）根据我要修复的参数的位置，我将被迫使用仅关键字调用，（2）我想要一些看起来更像普通类的东西，具有我修复的属性的self，随后由函数使用，（3）这只是一个单参数示例。你知道吗

我猜巧妙地使用修饰语和/或描述符可以做一些好事。你知道吗

Answer 1

这是一个类装饰器的示例，它在类方法中搜索想要的参数，并用partialmethod版本替换这些方法。我冻结了值为2的y参数，以表明它不涉及未使用y的方法。你知道吗

'''Freeze args in multiple functions wrapped as class methods,
   using a class decorator'''

import math
from functools import partialmethod
import inspect

class Calc:
    '''An imaginary Calc class with related methods that might share some args
    between them'''
    def add(self, x, y):
        return x + y
    def sub(self, x, y):
        return x - y
    def sqrt(self, x):
        return math.sqrt(x)

def partial_cls_arg_pairs(cls, arg_pairs):
    '''A class decorator to freeze arguments in class methods given
    as an arg_pairs iterable of argnames with argvalues'''
    cls_attrs = dict(cls.__dict__)
    freezed_cls_attrs = dict()
    for name, value in cls_attrs.items():
        if inspect.isfunction(value):
            for argname, argvalue in arg_pairs:
                if argname in inspect.signature(value).parameters:
                    print('Freezing args in {}.'.format(name))
                    value = partialmethod(value, **{argname:argvalue})
        freezed_cls_attrs[name] = value

    return type(cls.__name__, (object,), freezed_cls_attrs)

c1 = Calc()
print(c1.add(1,2))
print(c1.sub(3,2))
print(c1.sqrt(2))

print()

CalcY2 = partial_cls_arg_pairs(Calc, [('y', 2)])
c2 = CalcY2()
print(c2.add(1))
print(c2.sub(3))
print(c2.sqrt(2))

输出：

3
1
1.4142135623730951

Freezing args in add.
Freezing args in sub.
3
1
1.4142135623730951