这里是multimethod decorator的一个变体，它可以修饰类方法（原始的修饰纯函数）。我将变量命名为multidispatch，以消除与原始变量的歧义：import functools

def multidispatch(*types):

def register(function):

name = function.__name__

mm = multidispatch.registry.get(name)

if mm is None:

@functools.wraps(function)

def wrapper(self, *args):

types = tuple(arg.__class__ for arg in args)

function = wrapper.typemap.get(types)

if function is None:

raise TypeError("no match")

return function(self, *args)

wrapper.typemap = {}

mm = multidispatch.registry[name] = wrapper

if types in mm.typemap:

raise TypeError("duplicate registration")

mm.typemap[types] = function

return mm

return register

multidispatch.registry = {}

它可以这样使用：class Foo(object):

@multidispatch(str)

def render(self, s):

print('string: {}'.format(s))

@multidispatch(float)

def render(self, s):

print('float: {}'.format(s))

@multidispatch(float, int)

def render(self, s, t):

print('float, int: {}, {}'.format(s, t))

foo = Foo()

foo.render('text')

# string: text

foo.render(1.234)

# float: 1.234

foo.render(1.234, 2)

# float, int: 1.234, 2

上面的演示代码显示了如何根据参数的类型重载Foo.render方法。

这段代码搜索完全匹配的类型，而不是检查isinstance关系。可以修改它来处理这个问题（代价是查找O（n）而不是O（1）），但是因为听起来你不需要这样做，所以我将把代码放在这个更简单的格式中。