Python 中 in 运算符在集合和列表中的不同行为解析

Python 中 in 运算符在集合和列表中的不同行为解析

本文深入探讨了 Python 中 in 运算符在不同数据结构（尤其是列表和集合）中的行为差异。通过分析内部实现机制，解释了为何在特定场景下，使用列表会引发错误，而使用集合却能正常运行。同时，结合 PyTorch 张量的特性，提供了针对性解决方案和代码示例，帮助读者更好地理解和应用 in 运算符。

在 Python 中，in 运算符用于检查某个元素是否存在于一个集合（collection）中。然而，对于不同类型的集合，其内部实现机制存在差异，导致在某些情况下会产生不同的结果。本文将深入探讨 in 运算符在列表（list）和集合（set）中的行为差异，并结合具体的 PyTorch 张量示例，解释其背后的原因，并提供相应的解决方案。

in 运算符的工作原理

x in collection 的具体行为取决于 collection 的类型。通常，使用内部哈希表的数据结构（如集合和字典）与不使用哈希表的数据结构（如列表和元组）的处理方式不同。

不使用哈希表的集合（列表、元组等）

对于列表和元组等不使用哈希表的集合，x in collection 的内部实现逻辑如下（伪代码）：

立即学习“Python免费学习笔记（深入）”；

def is_in(x, collection):
  for c in collection:
      if (x is c or x==c):
          return True
  return False

该过程会遍历集合中的每个元素 c，依次进行身份比较 (x is c) 和相等性比较 (x == c)，直到找到第一个匹配项。

使用哈希表的集合（集合、字典等）

对于集合和字典等使用哈希表的集合，x in collection 的内部实现逻辑如下（伪代码）：

def is_in(x, collection):
  # 选择集合中哈希值与 x 相同的元素子集
  subset = get_subset_by_hash(collection, hash(x))
  for c in subset:
      if (x is c or x==c):
          return True
  return False

该过程首先根据 x 的哈希值，从集合中筛选出哈希值相同的元素子集 subset。然后，遍历 subset 中的每个元素 c，依次进行身份比较和相等性比较，直到找到第一个匹配项。哈希表的应用显著提高了查找效率，尤其是在大型数据集中。

实例分析

为了更深入地理解 in 运算符的行为，我们创建一个自定义类 MyObj，并定义其哈希计算逻辑 (__hash__) 和相等性判断逻辑 (__eq__)：

class MyObj:
    def __init__(self, val, hashval):
        self._val = val
        self._hashval = hashval

    def __hash__(self):
        print(f"{str(self)} calling __hash__")
        return self._hashval

    def __eq__(self, other):
        print(f"{str(self)} calling __eq__, {other=}")
        return super().__eq__(other)

    def __repr__(self):
        return f"<{self.__class__.__name__}: {self._val}>"

接下来，创建 MyObj 的几个实例，并分别构建一个集合 s 和一个列表 lst：

a = MyObj("a", 123)
b = MyObj("b", 456)
d = MyObj("d", 456)  # 与 b 具有相同的哈希值

print("Creating set `s`")
s = set([a, b, d])

print("Creating list `lst`")
lst = [a, b, d]

在创建集合时，Python 会计算每个元素的哈希值。如果存在哈希冲突（例如，b 和 d 具有相同的哈希值），则会调用 __eq__ 方法进行相等性判断。

企奶奶

一款专注于企业信息查询的智能大模型，企奶奶查企业，像聊天一样简单。

下载

在集合中使用 in 运算符

>>> s
{, , }
>>> b in s
 calling __hash__
True
>>> d in s
 calling __hash__
 calling __eq__, other=
 calling __eq__, other=
True

在集合中使用 in 运算符时，Python 首先计算 x 的哈希值。如果存在哈希冲突，则会调用 __eq__ 方法进行相等性判断。

在列表中使用 in 运算符

>>> lst
[, , ]
>>> a in lst
True
>>> b in lst
 calling __eq__, other=
 calling __eq__, other=
True
>>> d in lst
 calling __eq__, other=
 calling __eq__, other=
 calling __eq__, other=
 calling __eq__, other=
True

在列表中使用 in 运算符时，Python 会依次遍历列表中的每个元素，首先进行身份比较 (x is c)。如果身份比较失败，则调用 __eq__ 方法进行相等性判断。

PyTorch 张量的特殊情况

在 PyTorch 中，如果尝试比较两个大小不同的张量，会引发 RuntimeError。PyTorch 张量的哈希值是通过 id(self) 计算的，即对象的内存地址。

import torch
a = torch.Tensor(2,3)
b = torch.Tensor(2)

# case 1a:
# b  in list([a,a,b]) # raises an error: 
# Traceback (most recent call last):
#   File "", line 1, in 
# RuntimeError: The size of tensor a (2) must match the size of tensor b (3) at non-singleton dimension 0

# case 1b
b in set([a,a,b]) # True (i.e. no error)

当执行 b in list([a, b]) 时，会依次进行以下比较：

1. id(b) is id(a) -> False
2. b == a -> 引发 RuntimeError

由于 b == a 引发了错误，因此永远不会将 b 与列表中的 b 进行比较。

当执行 b in set([a, a, b]) 时，由于集合使用哈希表，会首先比较哈希值。因为 Tensor.__hash__ 返回张量的 id，所以集合的哈希表类似于 {id(a): a, id(b): b}。b in s 的执行过程如下：

1. hash(b) 是否与 s 的哈希表中的任何哈希值相同？是的，相同。
2. b is b？（in 运算符左侧的 b 是否与集合中具有相同哈希值的对象相同？）是的，相同。

因此，不会引发 RuntimeError。

总结： 列表会按顺序检查 (x is c or x==c)，而集合会首先检查哈希值，然后迭代集合中具有相同哈希值的所有项目，以检查 (x is c or x==c)。由于 hash(b) != hash(a)，因此几乎永远不会比较 b == a，从而避免了 RuntimeError。

解决方案

为了解决这个问题，可以利用 torch.Tensor.size 属性（它是元组的子类），并创建一个字典，其中键是张量的大小，值是具有该大小的张量的集合（或列表）。

import torch

tensors = {}
a = torch.Tensor(2, 3)
b = torch.Tensor(2)
c = torch.Tensor(2, 3)

def add_tensor(tensor, tensors):
  size = tuple(tensor.size())
  if size not in tensors:
    tensors[size] = set()
  tensors[size].add(tensor)

add_tensor(a, tensors)
add_tensor(b, tensors)
add_tensor(c, tensors)

def check_tensor(tensor, tensors):
  size = tuple(tensor.size())
  return tensor in tensors.get(size, set())

print(check_tensor(b, tensors)) # Output: True
print(check_tensor(torch.Tensor(2), tensors)) # Output: False

结论

本文详细分析了 Python 中 in 运算符在列表和集合中的不同行为，并结合 PyTorch 张量的特殊情况，解释了引发 RuntimeError 的原因。通过理解其内部实现机制，可以更好地选择合适的数据结构，并避免潜在的错误。同时，本文提供了针对性的解决方案，帮助读者在实际应用中更好地处理类似问题。