Python实现泛型函数的两种方法：singledispatch与自定义装饰器

在Python中实现泛型函数

所谓“泛型”，即参数化类型。提到参数，我们最熟悉的是定义方法时的形参以及调用时传递的实参。那么“参数化类型”该如何理解？顾名思义，就是将具体的类型抽象为参数形式（可称为类型形参），如同方法中的变量参数，在使用或调用时再传入具体的类型。

简易理解

泛型函数允许在定义时接收任意类型的参数。在调用时，函数会根据传入值的具体类型进行区分处理，从而实现特定效果。这种方式的主要优势在于提高代码复用率，减少冗余代码，是面向对象语言中泛型概念的重要体现。

接下来将使用Python库functools中的singledispatch模块来演示实现方法。

使用方法

只需在需要实现泛型行为的函数上添加相应的装饰器即可。

from functools import singledispatch
@singledispatch
def add(obj):
    return obj

• 1. singledispatch：用于标记处理函数传值类型的基础函数。
• 2. register(类型)：用于为特定传值类型注册处理逻辑并输出结果。
• 3. 后续调用无需重复书写函数名，只需使用register(类型)装饰器即可实现多态调用。
• 4. 可定义需要判断的具体类型，如int、str、tuple、dict、list、set等，根据实际需求进行选择。

在函数中实现类型判断逻辑

from functools import singledispatch
@singledispatch
def add(obj):
    return obj
int类型
@add.register(int)
def _(add):
    print("int类型")
@add.register(str)
def _(add):
    print("str类型")
    
@add.register(list)
def _(add):
    print("list类型")
    
@add.register(tuple)
def _(add):
    print("tuple类型")
    
@add.register(dict)
def _(add):
    print("dict类型")
    
@add.register(set)
def _(add):
    print("set类型")
    
add([1,2,3])  

输出结果：list类型

代码根据输入内容的具体类型进行判断并输出对应结果。

在类对象中使用泛型函数

from functools import singledispatch
class Type:
    @singledispatch
    def add(obj):
        return obj
    @add.register(int)
    def _(add):
        print("int类型")
    @add.register(str)
    def _(add):
        print("str")
    @add.register(list)
    def _(add):
        print("list类型")
    @add.register(tuple)
    def _(add):
        print("tuple类型")
    @add.register(dict)
    def _(add):
        print("dict类型")
    @add.register(set)
    def _(add):
        print("set类型")
Type.add([1,2,3])

输出结果：list类型

如果不调用singledispatch模块，如何实现泛型函数？

这里需要实现一个类型拼接操作，参考以下代码逻辑。

在此之前需要先定义一个装饰器，用于判断两个操作数的类型是否相同。如果类型不同，则不进行后续拼接判断，从而节省资源消耗。

def check_type(func):
    def wrapper(*args, **kwargs):
        args1, args2 = args[:2]
        if type(args1) != type(args2):
            return "两种类型不一致, 不能做拼接"
        return func(*args, **kwargs)
    return wrapper
@check_type
def add(obj1, obj2):
    if isinstance(obj1,list):
        obj1 += obj2
        return obj1
    if isinstance(obj1, str):
        obj1 += obj2
        return obj1
    if isinstance(obj1, tuple):
        obj1 += obj2
        return obj1
    if isinstance(obj1, dict):
        obj1 += obj2
        return obj1
print(add([1, 2, 3], [1, 2, 3]))

最终结果与使用singledispatch模块一致，开发者可根据实际需求选择合适方案。

该示例虽然简单，但多用于TCP/IP接收数据后的类型判断场景。

提示：bool类型同样可以参与判断，演示完毕。

Python泛型机制思考

近日在学习Python内容时接触到了泛型概念。从个人角度来看，Python的泛型实现与Java的泛型存在显著差异，在此提出一些个人见解。

首先，针对Java的泛型，其主要作用是在编写过程中作为未来才指定类型的占位符。在实例化过程中，这些泛型由参数具体指定，典型例子如集合类中的泛型定义。

List<String> list = new ArrayList<String>()

这相当于为集合类指定了新类型。使用泛型的原因在于加强类型转换的安全性以及减少不必要的类型转换次数。例如在List集合中，如果未指明泛型，取出的元素类型只能是Object，必须使用强制类型转换转化为对应类型后才能供后续代码使用。

此时可能存在问题：由于未指明泛型，加入集合时只要元素类型是Object（Java中Object为最高基类，意味着任何元素均可加入）即可插入。因此，无法保证取出的元素一定是预期类型，为保证程序健壮性，必须处理ClassCastException异常；而在指明泛型后，出入均可限制元素类型，从而减少了此类转换异常，保证了转换的安全性。

由以上描述可知，泛型首先要求在实例化时指定类型，因此泛型一般应用于强类型语言中效果更佳。但Python本身是弱类型语言，所以Python的泛型并不完全具备上述作用。

Python的泛型类Generic的注释中提到：

A generic type is typically declared by inheriting from an instantiation of this class with one or more type variables.

也就是说，Python的泛型类型是在继承该类之后才会声明，这种声明方式与Python的抽象类声明方式十分类似。以IO模块下的三个实现类为例，其声明分别为：

class IO(Generic[AnyStr]):
class BinaryIO(IO[bytes]):
class TextIO(IO[str]):

从这些定义中可以看出，在声明泛型类之后，IO类便可以使用泛型的方式作为其他类的基类定义。

并且AnyStr在Python的类型声明中包含了bytes与str两类。由此我们可以发现Python泛型与Java泛型的一个最根本区别：Python的泛型是在声明时就指定了泛型类型。也就是说，Python的泛型类型主要作用是：当某个类存在多种使用场景，且我们可以预知各个使用场景的类型时，为了将原始代码广泛应用于其他场景，使用泛型来保障代码在各场景上的通用性。因此，在泛型类的声明中并不像其他语言一样使用类似T的方式去替代类型，而是直接使用已经声明的泛型类型在代码中书写，例如readline函数的定义。

    @abstractmethod
    def readline(self, limit: int = -1) -> AnyStr:
        pass

由此，我们可以归纳Python泛型的两个条件：

1. 继承Generic类，并在类的参数中指明泛型类型。

2. 在实现中使用泛型类型参与代码编写。

最后，由于在声明时就已经指定了泛型的类型，所以Python泛型在很大程度上我认为是一个具有辅助说明的功能，相当于在编写过程中告诉编程人员应当使用什么类型。这其实从另一个层面上也是在其他语言中泛型功能的一大体现。

以上为个人经验总结，希望能给大家一个参考，也希望大家多多支持本站。