python 中的泛型/模板？

Question

python 如何处理泛型/模板类型场景？ 假设我想创建一个外部文件“BinaryTree.py”并让它处理二叉树，但适用于任何数据类型。

因此，我可以将自定义 object 的类型传递给它，并拥有该 object 的二叉树。 这是如何在 python 中完成的？

Answer 1

其他答案完全没问题：

• 不需要特殊的语法来支持 Python 中的 generics
• Python 使用André指出的鸭子类型。

但是，如果您仍然想要一个类型化的变体，那么自 Python 3.5 以来就有一个内置的解决方案。

Python 文档中提供了可用类型注释的完整列表。

---

通用类：

from typing import TypeVar, Generic, List

T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self) -> None:
        # Create an empty list with items of type T
        self.items: List[T] = []

    def push(self, item: T) -> None:
        self.items.append(item)

    def pop(self) -> T:
        return self.items.pop()

    def empty(self) -> bool:
        return not self.items

# Construct an empty Stack[int] instance
stack = Stack[int]()
stack.push(2)
stack.pop()
stack.push('x')        # Type error

---

通用函数：

from typing import TypeVar, Sequence

T = TypeVar('T')      # Declare type variable

def first(seq: Sequence[T]) -> T:
    return seq[0]

def last(seq: Sequence[T]) -> T:
    return seq[-1]


n = first([1, 2, 3])  # n has type int.

---

Static 类型检查：

您必须使用static 类型检查器，例如mypy或Pyre （由 Meta/FB 开发）来分析您的源代码。

安装 mypy：

python3 -m pip install mypy

分析您的源代码，例如某个文件：

mypy foo.py

或目录：

mypy some_directory

mypy 将检测并打印类型错误。 上面提供的堆栈示例的具体 output：

foo.py:23: error: Argument 1 to "push" of "Stack" has incompatible type "str"; expected "int"

---

参考：关于generics和运行 mypy 的mypy 文档

Answer 2

Python 使用鸭子类型，所以它不需要特殊的语法来处理多种类型。

如果您来自 C++ 背景，您会记得，只要模板函数/类中使用的操作是在某个类型T （在语法级别）上定义的，您就可以在模板中使用该类型T

因此，基本上，它的工作方式相同：

1. 为要在二叉树中插入的项目类型定义合同。
2. 记录此合同（即在 class 文档中）
3. 仅使用合约中指定的操作来实现二叉树
4. 请享用

但是，您会注意到，除非您编写显式类型检查（通常不鼓励这样做），否则您将无法强制二叉树仅包含所选类型的元素。

Answer 3

实际上，现在您可以在 Python 3.5+ 中使用 generics。 请参阅PEP-484和输入模块文档。

根据我的实践，它不是非常无缝和清晰，特别是对于那些熟悉 Java Generics 但仍然可用的人。

Answer 4

在对在 python 中创建泛型类型提出了一些好的想法后，我开始寻找其他有相同想法的人，但我找不到。 所以，就在这里。 我试过了，效果很好。 它允许我们在 python 中参数化我们的类型。

class List( type ):

    def __new__(type_ref, member_type):

        class List(list):

            def append(self, member):
                if not isinstance(member, member_type):
                    raise TypeError('Attempted to append a "{0}" to a "{1}" which only takes a "{2}"'.format(
                        type(member).__name__,
                        type(self).__name__,
                        member_type.__name__ 
                    ))

                    list.append(self, member)

        return List 

您现在可以从此泛型类型派生类型。

class TestMember:
        pass

class TestList(List(TestMember)):

    def __init__(self):
        super().__init__()


test_list = TestList()
test_list.append(TestMember())
test_list.append('test') # This line will raise an exception

这个解决方案很简单，但它确实有它的局限性。 每次创建泛型类型时，都会创建一个新类型。 因此，多个继承List( str )作为父类的类将继承自两个单独的类。 为了克服这个问题，您需要创建一个字典来存储内部 class 的各种 forms 并返回先前创建的内部 class，而不是创建一个新的。 这将防止创建具有相同参数的重复类型。 如果有兴趣，可以使用装饰器和/或元类制作更优雅的解决方案。

Answer 5

因为 Python 是动态类型的，所以在很多情况下对象的类型并不重要。 接受任何东西是一个更好的主意。

为了说明我的意思，这棵树 class 将接受它的两个分支的任何内容：

class BinaryTree:
    def __init__(self, left, right):
        self.left, self.right = left, right

它可以像这样使用：

branch1 = BinaryTree(1,2)
myitem = MyClass()
branch2 = BinaryTree(myitem, None)
tree = BinaryTree(branch1, branch2)

Answer 6

这是这个答案的一个变体，它使用元类来避免混乱的语法，并使用typing化的List[int]语法：

class template(type):
    def __new__(metacls, f):
        cls = type.__new__(metacls, f.__name__, (), {
            '_f': f,
            '__qualname__': f.__qualname__,
            '__module__': f.__module__,
            '__doc__': f.__doc__
        })
        cls.__instances = {}
        return cls

    def __init__(cls, f):  # only needed in 3.5 and below
        pass

    def __getitem__(cls, item):
        if not isinstance(item, tuple):
            item = (item,)
        try:
            return cls.__instances[item]
        except KeyError:
            cls.__instances[item] = c = cls._f(*item)
            item_repr = '[' + ', '.join(repr(i) for i in item) + ']'
            c.__name__ = cls.__name__ + item_repr
            c.__qualname__ = cls.__qualname__ + item_repr
            c.__template__ = cls
            return c

    def __subclasscheck__(cls, subclass):
        for c in subclass.mro():
            if getattr(c, '__template__', None) == cls:
                return True
        return False

    def __instancecheck__(cls, instance):
        return cls.__subclasscheck__(type(instance))

    def __repr__(cls):
        import inspect
        return '<template {!r}>'.format('{}.{}[{}]'.format(
            cls.__module__, cls.__qualname__, str(inspect.signature(cls._f))[1:-1]
        ))

使用这个新的元类，我们可以将我链接到的答案中的示例重写为：

@template
def List(member_type):
    class List(list):
        def append(self, member):
            if not isinstance(member, member_type):
                raise TypeError('Attempted to append a "{0}" to a "{1}" which only takes a "{2}"'.format(
                    type(member).__name__,
                    type(self).__name__,
                    member_type.__name__ 
                ))

                list.append(self, member)
    return List

l = List[int]()
l.append(1)  # ok
l.append("one")  # error

这种方法有一些不错的好处

print(List)  # <template '__main__.List[member_type]'>
print(List[int])  # <class '__main__.List[<class 'int'>, 10]'>
assert List[int] is List[int]
assert issubclass(List[int], List)  # True

Answer 7

由于 python 是动态类型的，这非常容易。 实际上，您必须为 BinaryTree class 做额外的工作才能不使用任何数据类型。

例如，如果您想要用于将 object 放置在 object 中可用的树中的键值，来自key()之类的方法，您只需在对象上调用key() 。 例如：

class BinaryTree(object):

    def insert(self, object_to_insert):
        key = object_to_insert.key()

请注意，您永远不需要定义 class object_to_insert 的类型。 只要它有一个key()方法，它就可以工作。

例外情况是，如果您希望它与字符串或整数等基本数据类型一起使用。 您必须将它们包装在 class 中，以使它们与您的通用 BinaryTree 一起使用。 如果这听起来太重，并且您想要实际存储字符串的额外效率，抱歉，这不是 Python 擅长的。

Answer 8

如果您使用 Python 2 或想重写 java 代码。 他们不是真正的解决方案。 这是我在一个晚上的工作： https://github.com/FlorianSteenbuck/python-generics我仍然没有编译器，所以你目前这样使用它：

class A(GenericObject):
    def __init__(self, *args, **kwargs):
        GenericObject.__init__(self, [
            ['b',extends,int],
            ['a',extends,str],
            [0,extends,bool],
            ['T',extends,float]
        ], *args, **kwargs)

    def _init(self, c, a, b):
        print "success c="+str(c)+" a="+str(a)+" b="+str(b)

待办事项

• 编译器
• 让泛型类和类型工作（对于像<? extends List<Number>>之类的东西）
• 添加super支持
• 添加? 支持
• 代码清理

Answer 9

幸运的是，python 中的泛型编程已经做出了一些努力。 有一个库：通用

这是它的文档： http://generic.readthedocs.org/en/latest/

它多年来一直没有进展，但您可以大致了解如何使用和制作自己的库。

干杯

Answer 10

看看内置容器是如何做到的。 dict和list等包含你喜欢的任何类型的异构元素。 例如，如果你为你的树定义一个insert(val) function，它会在某个时候执行类似node.value = val的操作，而 Python 会处理 Z65E8800B5C6800AAD896F8AFCAZ2。