共计 8224 个字符,预计需要花费 21 分钟才能阅读完成。
摘要:Python 不反对函数重载。当咱们定义了多个同名的函数时,前面的函数总是会笼罩后面的函数,因而,在一个命名空间中,每个函数名仅会有一个注销项(entry)。
本文分享自华为云社区《为什么 Python 没有函数重载?如何用装璜器实现函数重载?》,原文作者:Python 猫。
函数重载指的是有多个同名的函数,然而它们的签名或实现却不同。当调用一个重载函数 fn 时,程序会测验传递给函数的实参 / 形参,并据此而调用相应的实现。
int area(int length, int breadth) {return length * breadth;}
float area(int radius) {return 3.14 * radius * radius;}
在以上例子中(用 c++ 编写),函数 area 被重载了两个实现。第一个函数接管两个参数(都是整数),示意矩形的长度和宽度,并返回矩形的面积。另一个函数只接管一个整型参数,示意圆的半径。
当咱们像 area(7) 这样调用函数 area 时,它会调用第二个函数,而 area(3,4) 则会调用第一个函数。
为什么 Python 中没有函数重载?
Python 不反对函数重载。当咱们定义了多个同名的函数时,前面的函数总是会笼罩后面的函数,因而,在一个命名空间中,每个函数名仅会有一个注销项(entry)。
注:这里说 Python 不反对函数重载,指的是在不必语法糖的状况下。应用 functools 库的 singledispatch 装璜器,Python 也能够实现函数重载。原文作者在文末的正文中专门提到了这一点。
通过调用 locals() 和 globals() 函数,咱们能够看到 Python 的命名空间中有什么,它们别离返回部分和全局命名空间。
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(object):
"""Function 类是对规范的 Python 函数的封装"""
def __init__(self, fn):
self.fn = fn
def __call__(self, *args, **kwargs):
"""当像函数一样被调用时,它就会调用被封装的函数,并返回该函数的返回值"""
return self.fn(*args, **kwargs)
def key(self, args=None):
"""返回一个 key,能惟一标识出一个函数(即使是被重载的)"""
# 如果不指定 args,则从函数的定义中提取参数
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__办法会调用被封装的函数,并返回计算的值(这没有啥特地的)。这使得 Function 的实例能够像函数一样被调用,并且它的行为与被封装的函数齐全一样。
def area(l, b):
return l * b
>>> func = Function(area)
>>> func.key()
('__main__', <class 'function'>, 'area', 2)
>>> func(3, 4)
12
在下面的例子中,函数 area 被封装在 Function 中,并被实例化成 func。key() 返回一个元组,其第一个元素是模块名__main__,第二个是类 <class ‘function’>,第三个是函数名 area,而第四个则是该函数接管的参数数量,即 2。
这个示例还显示出,咱们能够像调用一般的 area 函数一样,去调用实例 func,当传入参数 3 和 4 时,失去的后果是 12,这正是调用 area(3,4) 时会失去的后果。当咱们接下来使用装璜器时,这种行为将会派上用场。
构建虚构的命名空间
咱们要创立一个虚构的命名空间,用于存储在定义阶段收集的所有函数。
因为只有一个命名空间 / 注册表,咱们创立了一个单例类,并把函数保留在字典中。该字典的键不是函数名,而是咱们从 key 函数中失去的元组,该元组蕴含的元素能惟一标识出一个函数。
通过这样,咱们就能在注册表中保留所有的函数,即便它们有雷同的名称(但不同的参数),从而实现函数重载。
class Namespace(object):
"""Namespace 是一个单例类,负责保留所有的函数"""
__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):
"""在虚构的命名空间中注册函数,并返回 Function 类的可调用实例"""
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):
"""这是一个自定义的函数,能够装璜任何函数,并打印其执行过程的耗时"""
def wrapper_function(*args, **kwargs):
start_time = time.time()
# 调用被装璜的函数,并获取其返回值
value = fn(*args, **kwargs)
print("the function execution took:", time.time() - start_time, "seconds")
# 返回被装璜的函数的调用后果
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 所需的工夫。
每当解释器遇到一个函数定义时,就会调用装璜器函数 my_decorator(用它封装被装璜的函数,并将封装后的函数存储在 Python 的部分或全局命名空间中),对于咱们来说,它是在虚构命名空间中注册函数的现实钩子。
因而,咱们创立了名为 overload 的装璜器,它能在虚构命名空间中注册函数,并返回一个可调用对象。
def overload(fn):
"""用于封装函数,并返回 Function 类的一个可调用对象"""
return Namespace.get_instance().register(fn)
overload 装璜器借助命名空间的 .register() 函数,返回 Function 的一个实例。当初,无论何时调用函数(被 overload 装璜的),它都会调用由 .register() 函数所返回的函数——Function 的一个实例,其 call 办法会在调用期间应用指定的 args 和 kwargs 执行。
当初剩下的就是在 Function 类中实现__call__办法,使得它能依据调用期间传入的参数而调用相应的函数。
从命名空间中找到正确的函数
想要区别出不同的函数,除了通常的模块、类和函数名以外,还能够根据函数的参数数量,因而,咱们在虚构的命名空间中定义了一个 get 办法,它会从 Python 的命名空间中读取待辨别的函数以及实参,最初根据参数的不同,返回出正确的函数。咱们没有更改 Python 的默认行为,因而在原生的命名空间中,同名的函数只有一个。
这个 get 函数决定了会调用函数的哪个实现(如果重载了的话)。找到正确的函数的过程非常简单——先应用 key 办法,它利用函数和参数来创立出惟一的键(正如注册时所做的那样),接着查找这个键是否存在于函数注册表中;如果存在,则获取其映射的实现。
def get(self, fn, *args):
"""从虚构命名空间中返回匹配到的函数,如果没找到匹配,则返回 None"""
func = Function(fn)
return self.function_map.get(func.key(args=args))
get 函数创立了 Function 类的一个实例,这样就能够复用类的 key 函数来取得一个惟一的键,而不必再写创立键的逻辑。而后,这个键将用于从函数注册表中获取正确的函数。
实现函数的调用
后面说过,每次调用被 overload 装璜的函数时,都会调用 Function 类中的__call__办法。咱们须要让__call__办法从命名空间的 get 函数中,获取出正确的函数,并调用之。
__call__办法的实现如下:
def __call__(self, *args, **kwargs):
"""重写能让类的实例变可调用对象的__call__办法"""
# 根据参数,从虚构命名空间中获取将要调用的函数
fn = Namespace.get_instance().get(self.fn, *args)
if not fn:
raise Exception("no matching function found.")
# 调用被封装的函数,并返回调用的后果
return fn(*args, **kwargs)
该办法从虚构命名空间中获取正确的函数,如果没有找到任何函数,它就抛出一个 Exception,如果找到了,就会调用该函数,并返回调用的后果。
使用函数重载
筹备好所有代码后,咱们定义了两个名为 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 3.4 开始,Python 的 functools.singledispatch 反对函数重载。从 Python 3.8 开始,functools.singledispatchmethod 反对重载类和实例办法。感激 Harry Percival 的斧正。
总结
Python 不反对函数重载,然而通过应用它的根本构造,咱们捣鼓了一个解决方案。
咱们应用装璜器和虚构的命名空间来重载函数,并应用参数的数量作为区别函数的因素。咱们还能够依据参数的类型(在装璜器中定义)来区别函数——即重载那些参数数量雷同但参数类型不同的函数。
重载能做到什么水平,这仅仅受限于 getfullargspec 函数和咱们的设想。应用前文的思路,你可能会实现出一个更整洁、更洁净、更高效的办法,所以,请尝试实现一下吧。
注释到此结束。以下附上残缺的代码:
# 模块:overload.py
from inspect import getfullargspec
class Function(object):
"""Function is a wrap over standard python function
An instance of this Function class is also callable
just like the python function that it wrapped.
When the instance is "called" like a function it fetches
the function to be invoked from the virtual namespace and then
invokes the same.
"""
def __init__(self, fn):
self.fn = fn
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)
def key(self, args=None):
"""Returns the key that will uniquely identifies
a function (even when it is overloaded).
"""
if args is None:
args = getfullargspec(self.fn).args
return tuple([
self.fn.__module__,
self.fn.__class__,
self.fn.__name__,
len(args or []),
])
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 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)
specs = getfullargspec(fn)
self.function_map[func.key()] = fn
return func
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))
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)
最初,演示代码如下:
from overload import overload
@overload
def area(length, breadth):
return length * breadth
@overload
def area(radius):
import math
return math.pi * radius ** 2
@overload
def area(length, breadth, height):
return 2 * (length * breadth + breadth * height + height * length)
@overload
def volume(length, breadth, height):
return length * breadth * height
@overload
def area(length, breadth, height):
return length + breadth + height
@overload
def area():
return 0
print(f"area of cuboid with dimension (4, 3, 6) is: {area(4, 3, 6)}")
print(f"area of rectangle with dimension (7, 2) is: {area(7, 2)}")
print(f"area of circle with radius 7 is: {area(7)}")
print(f"area of nothing is: {area()}")
print(f"volume of cuboid with dimension (4, 3, 6) is: {volume(4, 3, 6)}")
英文:https://arpitbhayani.me/blogs…
作者:arprit
译者:豌豆花下猫
申明:本翻译是出于交流学习的目标,基于 CC BY-NC-SA 4.0 受权协定。为便于浏览,内容略有改变。
点击关注,第一工夫理解华为云陈腐技术~