亲宝软件园·资讯

展开

python泛型函数singledispatch

晨曦之枭 人气:0

@functools.singledispatch

将一个函数转变为单一分派的泛型函数

用 @singledispatch装饰一个函数,将定义一个泛型函数。注意,我们创建的函数获得分派的依据是第一个参数的类型:

from functools import singledispatch
@singledispatch
def fun(arg, verbose=False):
    if verbose:
        print("Let me just say,", end=" ")
    print(arg)

使用泛函数的register()属性,重载泛函数的实现。泛函数的register()属性是一个装饰器。对于有类型注释的函数,这个装饰器将自动匹配第一个参为该类型的已注册函数重载泛函数:

@fun.register
def _(arg: int, verbose=False):
    if verbose:
        print("Strength in numbers, eh?", end=" ")
    print(arg)
@fun.register
def _(arg: list, verbose=False):
    if verbose:
        print("Enumerate this:")
    for i, elem in enumerate(arg):
        print(i, elem)

当我们调用泛函数fun时,泛函数根据第一个参数的类型来分派相应的函数来重载实现。

第一个参数为int类型时:

>>> fun(42, verbose=True)
Strength in numbers, eh? 42

第一个参数为list类型时:

>>> fun(['spam', 'spam', 'eggs', 'spam'], verbose=True)
Enumerate this:
0 spam
1 spam
2 eggs
3 spam

如果用泛函数的register()属性进装饰的函数的参数没有类型注释,那么我们可以在register()装饰器中明确声明合适的类型:

@fun.register(complex)
def _(arg, verbose=False):
    if verbose:
        print("Better than complicated.", end=" ")
    print(arg.real, arg.imag)
>>>fun(6+5j, verbose=True)
Better than complicated. 6.0 5.0

为了能注册之前存在的函数和匿名函数,register()属性可以当作功能函数使用。

def nothing(arg, verbose=False):
    print("Nothing.")
    
fun.register(type(None), nothing)
fun.register(int,  lambda x, y, verbose=False: x+y) # 本人添加的,官网没有这个例子

注:经本人实验,如果泛函数出两个可分派的函数,那么,泛涵数将选择离调用最近的可分派的函数,即,泛函数将分派在顺序上最后定义的函数。

>>> fun(None)
Nothing.
>>>fun(1,2)
3

这个register()属性将返回一个未被装饰的函数,这个函数将激活装饰器的堆栈空间,同时为它创建一个独的测试运行单元。

>>>import decimal
>>> @fun.register(float)
... @fun.register(decimal.Decimal)
... def fun_num(arg, verbose=False):
...     if verbose:
...         print("Half of your number:", end=" ")
...     print(arg / 2)
...
>>> fun_num is fun
False

如果泛函数给出的具体类型,没有对应的注册函数的实现,那么泛函数将去寻找更一般化的实现。用@singledispatch装饰的原函数被注册了基本类型–object类型,也就是说如果找不到更好的实现,那么将使用@singledispatch装饰的原函数:

注:此例由本人提供。

>>>fun(bool,verbose=True)
Let me just say, <class 'bool'>

使用只读属性registry,可查看我们都注册了哪些类型的函数实现

>>> fun.registry.keys()
dict_keys([<class 'object'>, <class 'decimal.Decimal'>, <class 'float'>, <class 'int'>, <class 'list'>, <class 'complex'>, <class 'NoneType'>])
>>> fun.registry
{<class 'object'>: <function fun at 0x00000225F21AC268>, <class 'decimal.Decimal'>: <function fun_num at 0x00000225F2517378>, <class 'float'>: <function fun_num at 0x00000225F2517378>, <class 'int'>: <function <lambda> at 0x00000225F2596488>, <class 'list'>: <function _ at 0x00000225F25172F0>, <class 'complex'>: <function _ at 0x00000225F2596400>, <class 'NoneType'>: <function nothing at 0x00000225F258E400>}
>>> fun.registry[float]
<function fun_num at 0x00000225F2517378>
>>>fun.registry[object]
<function fun at 0x00000225F21AC268>

官方链接:https://docs.python.org/3/library/functools.html?highlight=functools wraps#functools.update_wrapper

singledispatch实现单分派泛函数和多分派泛函数

本次的主题是逐渐闯入无人区的泛型!!!

说到泛型,学过java的一定不陌生,泛型的本质是参数化类型,也就是所操作的数据类型被指定为一个参数。但是,学过python的大家是否了解过这部分,或者是使用呢?

那么,python该如何实现泛型呢?

你别说,还真有一个库可以实现!

我们首先导入singledispatch所在的库:

from functools import singledispatch

这个库只能针对函数的第一个参数进行泛型指定!

先指定一个主函数用singledispatch修饰一下,作为一个base, 之后在定义一些“子函数”用 @主函数名.register作为修饰器,并传入一个参数作为“子函数”第一个参数的类型的判断(只能传入一个参数)(这个参数就是“子函数”第一个参数的类型,也是主函数第一个参数的类型)。(注意:这里的子函数就是那个_,应为这个子函数只在泛函数里面会使用到,所以我们干脆不指定他的名字QAQ, 函数的参数也和主函数一样)

但是,这样局限性也太大了,根本没有什么实际用处,我们还要推广到多分派泛函数!!!

多分派泛函数的实现:(因为python只能对第一个参数进行判断泛型,所以我们需要添加一些自己的代码实现多分派反函数)

 我们在单分派的基础上使用isinstance进行了判断,保证其他参数的类型的一致性。

以上的多分派泛函数也可以这样写:

 每一个子函数使用了两个修饰器,但是这两个修饰器都是针对第一个参数的。

!!!你以为这样就完结了???

python 3.5  推出了新特性——参数后面加一个冒号和函数后面加一个->的用法:

(冒号是指该参数应该的参数类型,箭头是指函数应该的返回值)

他也是指定了参数的类型,但是呢,就算你传入的类型和冒号后面的不一样,也并不会报错(除非你有语法错误),所以,这并不是泛型。

但是他和泛型也有些关系,这涉及到了register修饰器的第二个用法:

 省略了register的参数,而使用’:‘符号进行指定。

!!!完结!!!

以上为个人经验,希望能给大家一个参考,也希望大家多多支持。

加载全部内容

相关教程
猜你喜欢
用户评论