Python中 in 操作符在集合与列表中的不同行为详解

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

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

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={other}")
        return self._val == other._val if isinstance(other, MyObj) else False

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

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]

>>> s
{<MyObj: a>, <MyObj: b>, <MyObj: d>}
>>> b in s
<MyObj: b> calling __hash__
True
>>> d in s
<MyObj: d> calling __hash__
<MyObj: b> calling __eq__, other=<MyObj: d>
<MyObj: d> calling __eq__, other=<MyObj: b>
True

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

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

# case 1a:
# b  in list([a,a,b]) # raises an error: 
# 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)

import torch

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

size_a = tuple(a.size())
size_b = tuple(b.size())

if size_a not in tensors_by_size:
    tensors_by_size[size_a] = set()
tensors_by_size[size_a].add(a)

if size_b not in tensors_by_size:
    tensors_by_size[size_b] = set()
tensors_by_size[size_b].add(b)

# Now you can check if a tensor of a certain size exists
target_tensor = torch.Tensor(2)
target_size = tuple(target_tensor.size())

if target_size in tensors_by_size:
    print("Tensor of size", target_size, "exists.")
    if target_tensor in tensors_by_size[target_size]:
        print("Tensor exists in the collection")
    else:
        print("Tensor of that size exists, but not that specific tensor.")
else:
    print("Tensor of size", target_size, "does not exist.")