找出是否可以使用 `in` 运算符

Question

找出in 运算符是否可以在python 中使用的最简单（也是最优雅）的方法是什么？ 如果我打开一个 python shell 并输入：

"" in 2

打印出来：

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: argument of type 'int' is not iterable

根据python-docs，一个可迭代对象是：

容器。iter()

返回一个迭代器对象。该对象需要支持下面描述的迭代器协议。如果一个容器支持不同的 迭代类型，可以提供额外的方法来专门 为这些迭代类型请求迭代器。 （一个对象的例子 支持多种形式的迭代将是一个树结构，它 支持广度优先和深度优先遍历。）这种方法 对应于 Python 的类型结构的 tp_iter 槽 Python/C API 中的对象。

所以

hasattr([], "__iter__") and hasattr({}, "__iter__")

按预期返回true，但是

hasattr("test_string", "__iter__")

返回假。但我可以使用

"test" in "test_string"

没有任何问题。

优雅我指的是不使用 try-except 解决方案

Answer 1

你可以检查'__contains__' in dir(theobject)是否，但我并不认为try不雅。

Answer 2

in（和not in）运算符使用__contains__() 来检查成员资格（通常）。检查这一点的最简单和最优雅的方法是__contains__ 属性的直接存在，或者Container 抽象基类：

hasattr(obj, '__contains__')

# Python 3: Container
import collections.abc
isinstance(obj, collections.abc.Container)

# Python 2: Container
import collections
isinstance(obj, collections.Container)

但是，文档确实提到：

对于未定义__contains__() 的对象，成员资格测试首先尝试通过__iter__() 进行迭代，然后通过__getitem__() 尝试旧的序列迭代协议，请参阅this section in the language reference。

所以，如果你想绝对确定 in 可以在不依赖 try-except 块的情况下使用，你应该使用：

hasattr(obj, '__contains__') or hasattr(obj, '__iter__') or hasattr(obj, '__getitem__')

如果你只期望container-like 对象，我会忽略__iter__()，甚至可能忽略__getitem__()，并坚持使用__contains__()。

Answer 3

试试是正确而优雅的方法。

首先，a in b 是否会引发异常取决于 a 和 b，而不仅仅是 b。

另一个问题是in 有多种工作方式。这是一个支持in但不支持迭代的对象示例：

>>> class EvenNumbers(object):
...     def __contains__(self, n):
...         return n % 2 == 0
...     
>>> even_numbers = EvenNumbers()
>>> 4 in even_numbers
True
>>> 5 in even_numbers
False
>>> for even_number in even_numbers:
...     pass
... 
TypeError: 'EvenNumbers' object is not iterable

这是一个支持迭代但没有定义__contains__的对象示例：

>>> import itertools as it
>>> even_numbers = (2*n for n in it.count())
>>> 4 in even_numbers
True
>>> even_numbers.__contains__
AttributeError: 'generator' object has no attribute '__contains__'

因此，要实现有效的 LBYL，您必须考虑a in b 可以工作（或不工作）的所有可能方法。我这里只列出了几个，还有几个。你会发现你的代码变得又长又丑，最终会意识到 try/except 一直是阻力最小的路径！

Answer 4

迭代器协议实际上不需要类型来支持__iter__。它需要一个类型支持__iter__ 或__getitem__，从0 开始连续整数参数。请参阅iter 函数以获得文档中对此的最佳解释。

所以，hasattr(x, "__iter__") 会在测试某些东西是否可迭代时给出假阴性。

那么，您如何做到这一点？好吧，即使你不喜欢它，正确的方法是：

try:
    i = iter(x)
except TypeError:
    # not iterable

---

另外，请注意，正如 hasattr 的文档所解释的那样：

这是通过调用getattr(object, name) 并查看它是否引发异常来实现的。

所以，实际上，您根本没有避免异常；您只是想出了一种更复杂的方法来引发异常并将该事实隐藏起来。

---

但与此同时，迭代首先是一个红鲱鱼。 in 运算符是使用 __contains__ 方法实现的。未定义 __contains__ 方法的容器类型将退回迭代和比较，但以这种方式实现它不需要类型。您可以拥有一个比迭代快得多的__contains__（如dict 和set）；你甚至可以成为一个容器而不是一个可迭代的。 （请注意，collections module ABCs 有单独的 Container 和 Iterable 基；两者都不依赖于另一个。）

---

那么，如果你真的想在没有任何异常处理的情况下这样做，你怎么能？

好吧，您必须检查以下至少一项是否属实：

• x 有一个 __contains__ 方法。
• x 有一个 __iter__ 方法。
• x 有一个 __getitem__ 方法，当使用数字 0 调用该方法时，要么成功返回，要么引发 IndexError。

即使您接受如果不实际尝试使用号码0 调用它就无法测试最后一个，并且只是假设拥有__getitem__ 是“足够接近”，您如何在没有依赖异常？

你真的不能。例如，您可以迭代 dir(x)，但这不适用于动态定义 __contains__ 的类，例如，在委托给 self.real_sequence 的 __getattr__ 方法中。

而且，即使你可以，如果你有一个类将__contains__ 定义为不带参数，会发生什么？该属性存在，但in 仍将引发TypeError。

所有这些都忽略了which special methods are looked up on the object and which on the type itself 上的（依赖于实现的）规则。例如，在 CPython 2.7 中：

>>> class C(object): pass
>>> c = C()
>>> c.__contains__ = lambda self, x: return True
>>> hasattr(c, '__contains__')
True
>>> c.__contains__(2)
True
>>> 2 in c
TypeError: argument of type 'C' is not iterable