I’ve been wondering how to write functions and methods with the same name but different parameters, as if we had “overloaded” them. According to wiki, this is called multiple dispatching because in Python it happens in run time but not compile time.
Fortunately, there has been a discussion on Stack Overflow: python-function-overload. People have showed various ways to solve this problem. For example, here’s a third-party library we can use: https://github.com/coady/mult…
I’ve also come up with a solution to this problem by slightly changing the code of David Beazley, the author of Python Cookbook, who used function annotations to implement multiple dispatchings. He has kindly put his code here: https://github.com/dabeaz/pyt…
And here’s my code. The main idea is to use a dictionary to map the name of arguments (instead of the annotation) to the corresponding functions. I stored the arguments’ names in a frozen set so that argument list [a, b, c] and [c, b, a] mean to call the same function.
class MultiMethod:
def __init__(self, name):
self._methods = {}
self.__name__ = name
def register(self, meth):
sig = inspect.signature(meth)
arg_names = []
for name, parm in sig.parameters.items():
if name == 'self':
continue
if parm.default is not inspect.Parameter.empty:
self._methods[frozenset(arg_names)] = meth
# we can make var_names a frozen set
# so that f(a, b, c) and f(c, b, a) means the same thing
arg_names.append(name)
self._methods[frozenset(arg_names)] = meth
def __call__(self, *args, **kwargs):
"""
call a method based on name of the arguments
*args is used to hold the "self" argument of the caller, which is
an instance of a class
"""
arg_names = frozenset(kwargs.keys())
meth = self._methods.get(arg_names, None)
if meth:
return meth(*args, **kwargs)
else:
raise TypeError(f"No matching method for arguments {arg_names}")
def __get__(self, instance, cls):
if instance is not None:
# MethodType bounds a method to an instance
return types.MethodType(self, instance)
else:
return self
This is enough to solve the problem raised in the discussion:
And we can use the rest of the code proivded by David to create a class whose methods can be overloaded:
All that said, in Python we can just use functions with different names to handle most of the situations. AoP also suggests us use overloading only when the functions perform the same task but have arguments of different types. So all of these multiple dispatching stuff I write here is just for summary, practice and fun 😀
转载请注明原文链接：关于python:Writing-Functions-with-Same-Name-and-Different-Parameters
