如何为namedtuple的子类提供额外的初始化？

Question

假设我有一个像这样的 namedtuple：

EdgeBase = namedtuple("EdgeBase", "left, right")

我想为此实现一个自定义哈希函数，因此我创建以下子类：

class Edge(EdgeBase):
    def __hash__(self):
        return hash(self.left) * hash(self.right)

由于该对象是不可变的，我希望仅计算哈希值一次，所以我这样做：

class Edge(EdgeBase):
    def __init__(self, left, right):
        self._hash = hash(self.left) * hash(self.right)

    def __hash__(self):
        return self._hash

这似乎有效，但我真的不确定Python中的子类化和初始化，尤其是元组。这个解决方案有什么陷阱吗？有推荐的方法吗？还好吗？提前致谢。

Answer 1

在 Python 3.7+ 中，您现在可以使用 数据类 轻松构建可哈希类。

Code

假设 left 和 right 的 int 类型，我们通过 unsafe_hash 使用默认哈希>⁺ 关键字：

import dataclasses as dc


@dc.dataclass(unsafe_hash=True)
class Edge:
    left: int
    right: int


hash(Edge(1, 2))
# 3713081631934410656

现在我们可以使用这些（可变的）可哈希对象作为集合中的元素或（字典中的键）。

{Edge(1, 2), Edge(1, 2), Edge(2, 1), Edge(2, 3)}
# {Edge(left=1, right=2), Edge(left=2, right=1), Edge(left=2, right=3)}

---

详细信息

我们也可以重写__hash__函数：

@dc.dataclass
class Edge:
    left: int
    right: int

    def __post_init__(self):
        # Add custom hashing function here
        self._hash = hash((self.left, self.right))         # emulates default

    def __hash__(self):
        return self._hash


hash(Edge(1, 2))
# 3713081631934410656

扩展@ShadowRanger的评论，OP的自定义哈希函数不可靠。特别是，属性值可以互换，例如 hash(Edge(1, 2)) == hash(Edge(2, 1))，这可能是无意的。

_{⁺注意，名称“不安全”表明尽管是可变对象，仍将使用默认哈希。这可能是不受欢迎的，特别是在需要不可变键的字典中。可以使用适当的关键字打开不可变哈希。另请参阅有关数据类中的哈希逻辑和相关问题。}

Answer 2

问题中的代码可以受益于 __init__ 中的超级调用，以防它在多重继承情况下被子类化，但在其他方面是正确的。

class Edge(EdgeBase):
    def __init__(self, left, right):
        super(Edge, self).__init__(left, right)
        self._hash = hash(self.left) * hash(self.right)

    def __hash__(self):
        return self._hash

虽然元组是只读的，但其子类的元组部分是只读的，但其他属性可以照常写入，这就是允许对 _hash 进行赋值的原因，无论它是在 __init__ 中还是在 __new__ 中完成。代码>.您可以通过将子类的 __slots__ 设置为 () 来使子类完全只读，这具有节省内存的额外好处，但随后您将无法分配给 _hash。

Answer 3

2017 年编辑： 结果是 namedtuple 不是一个好主意。 attrs 是现代的替代方案。

class Edge(EdgeBase):
    def __new__(cls, left, right):
        self = super(Edge, cls).__new__(cls, left, right)
        self._hash = hash(self.left) * hash(self.right)
        return self

    def __hash__(self):
        return self._hash

__new__ 是您想要在此处调用的内容，因为元组是不可变的。不可变对象在 __new__ 中创建，然后返回给用户，而不是在 __init__ 中填充数据。

cls 必须两次传递给 __new__ 上的 super 调用，因为出于历史/奇怪的原因，__new__ 是隐式的静态方法。