我们如何根据输入参数的数量分派到不同的类方法？

Question

我们想要一个包含两个同名方法的类，但是：

1. 存在一种只接受一个参数的方法。
2. 另一种方法接受两个或多个参数。

也许，要实现多重调度，一个人可以下载第三方库。

也许，另一种选择是用一个装饰器来装饰这个函数，它 curries 函数。

也许，我们然后使用

functools.singledispatch

来装饰柯里化函数？

class K:
    @dispatch
    def method():
        pass

    @method.register
    def method_of_one(one_arg):
        return the_slowball_klass

    # method.register(method_of_one)  

    @method.register
    def method_of_two(one_arg, two_args):
        return the_slowball_klass

    # method_of_two = method.register(method_of_two)  

Answer 1

您可以使用

*args

作为输入类型，使其接受可变数量的参数，然后打开参数长度。或者，如果您的目标只是接受多个参数，那就可以了。

Answer 2

我可以向您展示一种不处理边缘情况的基本方法，但它应该能让您前进

import inspect
import types

class dispatch:
    def __init__(self, func):
        self.funcs = {}
        self.register(func)
    def __call__(self, *args, **kwargs):
        func = self.funcs[len(args) + len(kwargs)]
        return func(*args, **kwargs)
    def register(self, func):
        self.funcs[len(inspect.signature(func).parameters)] = func
        return self
    def __get__(self, obj, owner):
        if obj is None:
            return self
        return types.MethodType(self, obj)

class K:
    @dispatch
    def foo(self):
        return 0
    @foo.register
    def foo(self, a):
        return a
    @foo.register
    def foo(self, a, b):
        return a + b

在 REPL 中：

In [2]: k = K()

In [3]: k.foo()
Out[3]: 0

In [4]: k.foo(1)
Out[4]: 1

In [5]: k.foo(1, 2)
Out[5]: 3