重载函数,即多个函数具有相同的名称,但功能不同。例如一个重载函数 fn
,调用它的时候,要根据传给函数的参数判断调用哪个函数,并且执行相应的功能。
int area(int length, int breadth) { return length * breadth; } float area(int radius) { return 3.14 * radius * radius; } 复制代码
上例是用C++写的代码,函数 area
就是有两个不同功能的重载函数,一个是根据参数length和breadth计算矩形的面积,另一个是根据参数radius(圆的半径)计算圆的面积。如果用 area(7)
的方式调用函数 area
,就会实现第二个函数功能,当 area(3, 4)
时调用的是第一个函数。
为什么Python中没有重载函数
Python中本没有重载函数,如果我们在同一命名空间中定义的多个函数是同名的,最后一个将覆盖前面的各函数,也就是函数的名称只能是唯一的。通过执行 locals()
和 globals()
两个函数,就能看到该命名空间中已经存在的函数。
def area(radius):
return 3.14 * radius ** 2 >>> locals() { ... 'area': <function area at 0x10476a440>, ... } 复制代码
定义了一个函数之后,执行 locals()
函数,返回了一个字典,其中是本地命名空间中所定义所有变量,键是变量,值则是它的引用。如果有另外一个同名函数,就会将本地命名空间的内容进行更新,不会有两个同名函数共存。所以,Python不支持重载函数,这是发明这个语言的设计理念,但是这并不能阻挡我们不能实现重载函数。下面就做一个试试。
在Python中实现重载函数
我们应该知道Python怎么管理命名空间,如果我们要实现重载函数,必须:
- 在稳定的虚拟命名空间管理所定义的函数
- 根据参数调用合适的函数
为了简化问题,我们将实现具有相同名称的重载函数,它们的区别就是参数的个数。
封装函数
创建一个名为 Function
的类,并重写实现调用的 __call__
方法,再写一个名为 key
的方法,它会返回一个元组,这样让就使得此方法区别于其他方法。
from inspect import getfullargspec
class Function:
"""Function is a wrap over standard python function. """ def __init__(self, fn): self.fn = fn def __call__(self, *args, **kwargs): """when invoked like a function it internally invokes the wrapped function and returns the returned value. """ return self.fn(*args, **kwargs) def key(self, args=None): """Returns the key that will uniquely identify a function (even when it is overloaded). """ # if args not specified, extract the arguments from the # function definition if args is None: args = getfullargspec(self.fn).args return tuple([ self.fn.__module__, self.fn.__class__, self.fn.__name__, len(args or []), ]) 复制代码
在上面的代码片段中, key
方法返回了一个元组,其中的元素包括:
- 函数所属的模块
- 函数所属的类
- 函数名称
- 函数的参数长度
在重写的 __call__
方法中调用作为参数的函数,并返回计算结果。这样,实例就如同函数一样调用,它的表现效果与作为参数的函数一样。
def area(l, b):
return l * b
>>> func = Function(area) >>> func.key() ('__main__', <class 'function'>, 'area', 2) >>> func(3, 4) 12 复制代码
在上面的举例中,函数 area
作为 Function
实例化的参数, key()
返回的元组中,第一个元素是模块的名称 __main__
,第二个是类 <class 'function'>
,第三个是函数的名字 area
,第四个则是此函数的参数个数 2
。
从上面的示例中,还可以看出,调用实例 func
的方式,就和调用 area
函数一样,提供参数 3
和 4
,就返回 12
,前面调用 area(3, 4)
也是同样结果。这种方式,会在后面使用装饰器的时候很有用。
构建虚拟命名空间
我们所构建的虚拟命名空间,会保存所定义的所有函数。
class Namespace(object):
"""Namespace is the singleton class that is responsible
for holding all the functions.
"""
__instance = None def __init__(self): if self.__instance is None: self.function_map = dict() Namespace.__instance = self else: raise Exception("cannot instantiate a virtual Namespace again") @staticmethod def get_instance(): if Namespace.__instance is None: Namespace() return Namespace.__instance def register(self, fn): """registers the function in the virtual namespace and returns an instance of callable Function that wraps the function fn. """ func = Function(fn) self.function_map[func.key()] = fn return func 复制代码
Namespace
类中的方法 register
以函数 fn
为参数,在此方法内,利用 fn
创建了 Function
类的实例,还将它作为字典的值。那么,方法 register
的返回值,也是一个可调用对象,其功能与前面封装的 fn
函数一样。
def area(l, b):
return l * b
>>> namespace = Namespace.get_instance() >>> func = namespace.register(area) >>> func(3, 4) 12 复制代码
用装饰器做钩子
我们已经定义了一个虚拟命名空间,并且可以向其中注册一个函数,下面就需要一个钩子,在该函数生命周期内调用它,为此使用Python的装饰器。在Python中,装饰器是一种封装的函数,可以将它加到一个已有函数上,并不需要理解其内部结构。装饰器接受函数 fn
作为参数,并且返回另外一个函数,在这个函数被调用的时候,可以用 args
和 kwargs
为参数,并得到返回值。
下面是一个简单的封装器示例:
import time
def my_decorator(fn):
"""my_decorator is a custom decorator that wraps any function and prints on stdout the time for execution. """ def wrapper_function(*args, **kwargs): start_time = time.time() # invoking the wrapped function and getting the return value. value = fn(*args, **kwargs) print("the function execution took:", time.time() - start_time, "seconds") # returning the value got after invoking the wrapped function return value return wrapper_function @my_decorator def area(l, b): return l * b >>> area(3, 4) the function execution took: 9.5367431640625e-07 seconds 12 复制代码
在上面的示例中,定义了名为 my_decorator
的装饰器,并用它装饰函数 area
,在交互模式中调用,打印出 area(3,4)
的执行时间。
装饰器 my_decorator
装饰了一个函数之后,当执行函数的时候,该装饰器函数也每次都要调用,所以,装饰器函数是一个理想的钩子,借助它可以向前述定义的虚拟命名空间中注册函数。下面创建一个名为 overload
的装饰器,用它在虚拟命名空间注册函数,并返回一个可执行对象。
def overload(fn):
"""overload is the decorator that wraps the function
and returns a callable object of type Function.
"""
return Namespace.get_instance().register(fn) 复制代码
overload
装饰器返回 Function
实例,作为 .register()
的命名空间。现在,不论什么时候通过 overload
调用函数,都会返回 .register()
,即 Function
实例,并且,在调用的时候, __call__
也会执行。
从命名空间中查看函数
除通常的模块类和名称外,消除歧义的范围是函数接受的参数数,因此我们在虚拟命名空间中定义了一个称为 get
的方法,该方法接受Python命名空间中的函数(将是最后一个同名定义 - 因为我们没有更改 Python 命名空间的默认行为)和调用期间传递的参数(我们的非义化因子),并返回要调用的消除歧义函数。
此 get
函数的作用是决定调用函数的实现(如果重载)。获取适合函数的过程非常简单,从函数和参数创建使用 key
函数的唯一键(在注册时完成),并查看它是否存在于函数注册表中,如果在,就执行获取针对它存储操作。
def get(self, fn, *args):
"""get returns the matching function from the virtual namespace.
return None if it did not fund any matching function.
"""
func = Function(fn)
return self.function_map.get(func.key(args=args)) 复制代码
在 get
函数中创建了 Function
的实例,它可以用 key
方法得到唯一的键,并且不会在逻辑上重复,然后使用这个键在函数注册表中得到相应的函数。
调用函数
如上所述,每当被 overload
装饰器装饰的函数被调用时,类 Function
中的方法 __call__
也被调用,从而通过命名空间的 get
函数得到恰当的函数,实现重载函数功能。 __call__
方法的实现如下:
def __call__(self, *args, **kwargs):
"""Overriding the __call__ function which makes the
instance callable.
"""
# fetching the function to be invoked from the virtual namespace # through the arguments. fn = Namespace.get_instance().get(self.fn, *args) if not fn: raise Exception("no matching function found.") # invoking the wrapped function and returning the value. return fn(*args, **kwargs) 复制代码
这个方法从虚拟命名空间中得到恰当的函数,如果它没有找到,则会发起异常。
重载函数实现
将上面的代码规整到一起,定义两个名字都是 area
的函数,一个计算矩形面积,另一个计算圆的面积,两个函数均用装饰器 overload
装饰。
@overload
def area(l, b):
return l * b @overload def area(r): import math return math.pi * r ** 2 >>> area(3, 4) 12 >>> area(7) 153.93804002589985 复制代码
当我们给调用的 area
传一个参数时,返回圆的面积,两个参数时则计算了矩形面积,这样就实现了重载函数 area
。
结论
Python不支持函数重载,但通过使用常规的语法,我们找到了它的解决方案。我们使用修饰器和用户维护的命名空间来重载函数,并使用参数数作为消除歧义因素。还可以使用参数的数据类型(在修饰中定义)来消除歧义—— 它允许具有相同参数数但不同类型的函数重载。重载的粒度只受函数 getfullargspec
和我们的想象力的限制。更整洁、更简洁、更高效的方法也可用于上述构造。