Python中的动态调度和继承

Question

我正在尝试修改Guido的多重方法（动态分发代码）：

http://www.artima.com/weblogs/viewpost.jsp?thread=101605

目的是让它能够处理继承关系，并可能支持参数顺序不固定的情况。

比如说（继承问题）

class A(object):
  pass

class B(A):
  pass

@multimethod(A,A)
def foo(arg1,arg2):
  print 'works'


foo(A(),A()) #works

foo(A(),B()) #fails

有没有比一个个检查每个项的super()，直到找到一个更好的方法？

比如说（参数顺序问题）

我在考虑这个问题时，是从碰撞检测的角度出发的。

例如：

foo(Car(),Truck()) and
foo(Truck(), Car()) and

这两个都应该触发

foo(Car,Truck) # Note: @multimethod(Truck,Car) will throw an exception if @multimethod(Car,Truck) was registered first?

我特别想要一个“优雅”的解决方案。我知道我可以通过穷举所有可能性来解决，但我想避免这样做。在动手写解决方案之前，我只是想先收集一些意见和想法。

谢谢

Answer 1

super() 返回的是一个代理对象，而不是父类（因为你可以有多个父类），所以这样做是行不通的。使用 isinstance() 是最好的选择，虽然它没有用 type(arg) 进行字典查找那么优雅。

我觉得允许参数顺序不同并不是个好主意；这样可能会导致一些意想不到的问题，而且要让它与继承兼容也会非常麻烦。不过，创建一个第二个装饰器来处理“如果所有参数都是类型 A，就使用这个函数”或者“如果所有参数都是类型 {A, B, E}，就使用这个函数”会比较简单。

Answer 2

关于继承的问题：我们可以稍微修改一下MultiMethod来解决这个问题。具体来说，就是遍历self.typemap，并用issubclass来检查。

registry = {}

class MultiMethod(object):
    def __init__(self, name):
        self.name = name
        self.typemap = {}
    def __call__(self, *args):
        types = tuple(arg.__class__ for arg in args) # a generator expression!
        for typemap_types in self.typemap:
            if all(issubclass(arg_type,known_type)
                   for arg_type,known_type in zip(types,typemap_types)):
                function = self.typemap.get(typemap_types)
                return function(*args)
        raise TypeError("no match")
    def register(self, types, function):
        if types in self.typemap:
            raise TypeError("duplicate registration")
        self.typemap[types] = function

def multimethod(*types):
    def register(function):
        name = function.__name__
        mm = registry.get(name)
        if mm is None:
            mm = registry[name] = MultiMethod(name)
        mm.register(types, function)
        return mm
    return register

class A(object):
  pass

class B(A):
    pass

class C(object):
    pass

@multimethod(A,A)
def foo(arg1,arg2):
  print 'works'


foo(A(),A()) #works

foo(A(),B()) #works

foo(C(),B()) #raises TypeError

需要注意的是，self.typemap是一个字典，而字典是无序的。所以如果你用@multimethod来注册两个函数，其中一个的类型是另一个的子类，那么foo的行为可能就不确定了。也就是说，结果会依赖于在循环for typemap_types in self.typemap中，哪个typemap_types先出现。