Python中类的列表或散列的in运算符的机制是什么？

我试图理解如何在Python中实现对象列表或散列。更具体地说，在中，这是我能得到的最接近的，我通过做以下事情看到了这一点：

class MyClass(object):

def __init__(self):
    self.numbers = [1,2,3,4,54]

def __contains__(self, key):
    return key in self.numbers

>>> m = MyClass()
>>> 54 in m
True

我可以直接在类上使用中的运算符来检查其内部的属性

我的问题是这个问题的延伸。假设我有一个MyClass对象的列表或散列，即：

list = [m1,m2,m3]
hash = {m1,m2,m3}

我想使用如下内容：

if 54 in list: 
   #do something
if 54 in hash: 
   #do something

需要在MyClass中定义哪些方法才能使in运算符工作？我不确定in是做什么的（如果是a==就需要一个uuu eq或其他东西）。如果您碰巧知道如何使.index（）在这种情况下工作，我也将不胜感激

编辑：很抱歉，最初的问题让人困惑。我希望我说清楚了。我试图找到一个属于类的属性，比如另一个问题的原始示例。但现在我试图在一个列表或散列中这样做。从某种意义上说，我希望通过询问元素是否在列表中，它会询问元素是否在列表的每个元素中。我不确定在列表或哈希中使用运算符是否会这样做，或者使用==进行比较

---

谢谢。

当

在

中测试容器时，它将根据您的自定义类型检查是否相等

换句话说，某些序列中的ob可被视为：

any((ob is contained_ob or ob == contained_ob) for contained_ob in some_sequence)

两个自定义类

ob1

和

ob2

在以下情况下测试为相等：

它们是相同的，

ob1是ob2

是真的。它们是同一个物体

如果

ob1

具有

\uuuuu eq\uuuu

方法，则测试

ob1.\uuuuu eq\uuuu（ob2）

如果

ob1

没有这样的方法，但

ob2.\uuuu eq\uuu（）

确实存在，则尝试

ob2.\uuuu eq\uu（ob1）

---

您还可以定义

\uu ne\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
 当

中的

测试包含时，它将根据您的自定义类型检查是否相等

换句话说，某些序列中的ob可被视为：

any((ob is contained_ob or ob == contained_ob) for contained_ob in some_sequence)

两个自定义类
ob1
和
ob2
在以下情况下测试为相等：

它们是相同的，
ob1是ob2
是真的。它们是同一个物体
如果
ob1
具有
\uuuuu eq\uuuu
方法，则测试
ob1.\uuuuu eq\uuuu（ob2）
如果
ob1
没有这样的方法，但
ob2.\uuuu eq\uuu（）
确实存在，则尝试
ob2.\uuuu eq\uu（ob1）
您还可以定义
\uu ne\uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
 正如@MartijnPieters所说，您应该重载
\uuuu eq\uuu（）
方法。我不知道你给出的哈希/字典示例是什么意思

class MyClass(object):

    def __init__(self):
        self.numbers = [1,2,3,4,54]

    def __contains__(self, key):
        return key in self.numbers

    def __eq__(self, other):
        if other in self.numbers:
            return True
        else:
            return False


m1 = MyClass()
m2 = MyClass()
m3 = MyClass()

test1 = 54 in [m1, m2, m3]
print test1
#True
test2 = 666 in [m1, m2, m3]
print test2
#False

正如@MartijnPieters所说，您应该重载
\uuu eq\uu（）
方法。我不知道你给出的哈希/字典示例是什么意思

class MyClass(object):

    def __init__(self):
        self.numbers = [1,2,3,4,54]

    def __contains__(self, key):
        return key in self.numbers

    def __eq__(self, other):
        if other in self.numbers:
            return True
        else:
            return False


m1 = MyClass()
m2 = MyClass()
m3 = MyClass()

test1 = 54 in [m1, m2, m3]
print test1
#True
test2 = 666 in [m1, m2, m3]
print test2
#False

在Python术语中，它被称为映射。默认实现是dict类型或dictionary。当你谈论散列时，你谈论的是在映射中存储键时使用的不透明值。这个问题还很不清楚。如果你做了一个类的对象列表，你只需要在列表中使用操作符“in”——你不需要在类中提供任何东西。要在Python
set
（您正在调用“hash”）中使用，只需向类中添加一个返回整数的“hash”方法。请注意，您的
hash
名称定义的是一个
set（）
，而不是一个映射。您没有键值对。很抱歉，我在这个问题上打错了。我现在正在更正它。我想要的是约定一个标识符，它是类的一个属性，在Python术语中称为映射。默认实现是dict类型或dictionary。当你谈论散列时，你谈论的是在映射中存储键时使用的不透明值。这个问题还很不清楚。如果你做了一个类的对象列表，你只需要在列表中使用操作符“in”——你不需要在类中提供任何东西。要在Python
set
（您正在调用“hash”）中使用，只需向类中添加一个返回整数的“hash”方法。请注意，您的
hash
名称定义的是一个
set（）
，而不是一个映射。您没有键值对。很抱歉，我在这个问题上打错了。我现在正在更正它。我想要的是约定一个标识符，它是类的一个属性。虽然any（）-行不太正确，但其余的是精确的。x.\uuuuu eq\uuuuuux（x）产生false的对象x仍然是
[x]中的
+1它不是更像
any（ob是c_ob或ob==c_ob..etc
）吗？我以为身份是先测试的。实际上，仔细想想，我认为文档在这一点上是错误的——它说“对于列表和元组类型，
x in y
是真的，当且仅当存在一个索引I，使得
x==y[I]
是真的”，但快速测试表明，即使我强制
\uuueq\uucode>提出，身份仍然在平等之前被测试，[np.nan]
中的
np.nan是真的。@Martjin所以如果我理解你的答案是正确的，为了测试[m1，m2，m3]中的54，其中每个m都是MyClass的对象，我需要定义的是MyClass的eq，而不是包含。是吗？@OeufcoquePenteano:正确，是的。虽然any（）-行不太正确，但其余的都是精确的。x.\uuuuu eq\uuuuuux（x）产生false的对象x仍然是
[x]中的
+1它不是更像
any（ob是c_ob或ob==c_ob..etc
）吗？我以为身份是先测试的。事实上，仔细想想，我认为文档在这一点上是错误的——它说“为