python 如何处理泛型/模板类型场景？假设我想创建一个外部文件“BinaryTree.py”并让它处理二叉树，但适用于任何数据类型。
所以我可以将自定义对象的类型传递给它，并拥有该对象的二叉树。这是如何在 python 中完成的？
问问题
149111 次
9 回答
141
其他答案完全没问题：
- 不需要特殊的语法来支持 Python 中的泛型
- 正如André所指出的，Python 使用鸭子类型。
但是，如果你仍然想要一个类型化的变体，那么从 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 type checker诸如mypy或Pyre（由 Meta/FB 开发）来分析您的源代码。
安装 mypy：
python3 -m pip install mypy
分析您的源代码，例如某个文件：
mypy foo.py
或目录：
mypy some_directory
mypy 将检测并打印类型错误。上面提供的 Stack 示例的具体输出：
foo.py:23: error: Argument 1 to "push" of "Stack" has incompatible type "str"; expected "int"
参考：关于泛型和运行 mypy 的mypy 文档
于 2020-01-04T10:36:50.843 回答
103
Python 使用鸭子类型，因此它不需要特殊的语法来处理多种类型。
如果您有 C++ 背景，您会记得，只要在模板函数/类中使用的操作是在某种类型T（在语法级别）上定义的，您就可以T在模板中使用该类型。
因此，基本上，它的工作方式相同：
- 为要在二叉树中插入的项目类型定义合同。
- 记录此合同（即在课程文档中）
- 仅使用合约中指定的操作来实现二叉树
- 请享用
但是，您会注意到，除非您编写显式类型检查（通常不鼓励这样做），否则您将无法强制二叉树仅包含所选类型的元素。
于 2011-07-17T18:38:34.073 回答
12
在对在 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 )作为父类继承的多个类将继承自两个单独的类。为了克服这个问题，您需要创建一个dict来存储内部类的各种形式并返回之前创建的内部类，而不是创建一个新的。这将防止创建具有相同参数的重复类型。如果有兴趣，可以使用装饰器和/或元类制作更优雅的解决方案。
于 2016-03-28T13:32:47.497 回答
3
由于python是动态类型的，这非常容易。事实上，您必须为 BinaryTree 类做额外的工作才能不使用任何数据类型。
例如，如果您想要用于将对象放置在树中的键值可从对象中获得，例如key()您只需调用key()对象。例如：
class BinaryTree(object):
def insert(self, object_to_insert):
key = object_to_insert.key()
请注意，您永远不需要定义 object_to_insert 是哪种类。只要它有key()方法，它就会起作用。
例外情况是，如果您希望它与字符串或整数等基本数据类型一起使用。您必须将它们包装在一个类中以使它们与您的通用 BinaryTree 一起使用。如果这听起来太重了，并且您想要实际存储字符串的额外效率，那么抱歉，这不是 Python 擅长的。
于 2011-07-17T18:36:13.377 回答
2
如果你使用 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支持 - 添加
?支持 - 代码清理
于 2018-09-18T11:29:09.140 回答
2
这是这个答案的一个变体，它使用元类来避免混乱的语法，并使用typing-styleList[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
于 2019-11-16T12:53:36.357 回答
1
看看内置容器是如何做到的。 dict等等list包含你喜欢的任何类型的异构元素。例如，如果你insert(val)为你的树定义一个函数，它会在某个时候做类似的事情，node.value = val而 Python 会处理剩下的事情。
于 2011-07-17T18:35:22.510 回答
1
幸运的是，python 中的泛型编程已经做出了一些努力。有一个库：通用
这是它的文档：http: //generic.readthedocs.org/en/latest/
它多年来一直没有进展，但您可以大致了解如何使用和制作自己的库。
干杯
于 2014-10-25T06:02:27.437 回答