检查 Python 中某个东西是否存在于列表中

问题描述：

我在Python中有一个元组列表，并且我有一个条件，只有当元组不在列表中时我才想采取分支（如果它在列表中，那么我不想采取 if 分支）

if curr_x -1 > 0 and (curr_x-1 , curr_y) not in myList: 

    # Do Something

但这对我来说真的不起作用。我做错了什么？

解决方案 1：

这个错误可能出现在你代码的其他地方，因为它应该可以正常工作：

>>> 3 not in [2, 3, 4]
False
>>> 3 not in [4, 5, 6]
True

或者使用元组：

>>> (2, 3) not in [(2, 3), (5, 6), (9, 1)]
False
>>> (2, 3) not in [(2, 7), (7, 3), "hi"]
True

解决方案 2：

如何检查某个东西是否存在于 Python 列表中？

最便宜、最易读的解决方案是使用in运算符（或者根据您的具体情况，使用not in）。如文档中所述，

运算符in和not in测试成员资格。如果是的成员，则x in s计算为
，否则。返回的否定。True`xsFalsex not in sx in s`

此外，

运算符not in被定义为具有 的逆真值in。

y not in x在逻辑上与 相同not y in x。

以下是一些示例：

'a' in [1, 2, 3]
# False

'c' in ['a', 'b', 'c']
# True

'a' not in [1, 2, 3]
# True

'c' not in ['a', 'b', 'c']
# False

这也适用于元组，因为元组是可哈希的（因为它们也是不可变的）：

(1, 2) in [(3, 4), (1, 2)]
#  True

如果 RHS 上的对象定义了一种__contains__()方法，则会在内部调用它，如文档比较in部分的最后一段所述。

...in和not in，由可迭代或实现该方法的类型支持
__contains__()。例如，您可以（但不应该）这样做：

[3, 2, 1].__contains__(1)
# True

in短路，因此如果您的元素位于列表的开头，则in可以更快地进行评估：

lst = list(range(10001))
%timeit 1 in lst
%timeit 10000 in lst  # Expected to take longer time.

68.9 ns ± 0.613 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
178 µs ± 5.01 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

如果您想要做的不仅仅是检查某个项目是否在列表中，那么还有以下选项：

• list.index可用于检索项目的索引。如果该元素不存在，则ValueError引发。

• list.count如果您想计算发生次数，可以使用。

XY 问题：您考虑过吗set？

问自己这些问题：

• 您是否需要检查某个项目是否多次出现在列表中？

• 这个检查是在循环内完成的，还是在重复调用的函数中完成的？

• 您存储在列表中的项目是否可以哈希化？换句话说，您可以调用hash它们吗？

如果您对这些问题的回答是“是”，则应该使用 a set。in对 s 进行成员资格测试的list时间复杂度为 O(n)。这意味着 Python 必须对列表进行线性扫描，访问每个元素并将其与搜索项进行比较。如果您重复执行此操作，或者列表很大，则此操作将产生开销。

set另一方面，对象会对其值进行哈希处理，以进行常量时间成员资格检查。检查也是使用以下方法完成的in：

1 in {1, 2, 3} 
# True

'a' not in {'a', 'b', 'c'}
# False

(1, 2) in {('a', 'c'), (1, 2)}
# True

如果你不幸搜索/不搜索的元素位于列表末尾，python 将扫描列表直到末尾。从以下时间可以看出这一点：

l = list(range(100001))
s = set(l)

%timeit 100000 in l
%timeit 100000 in s

2.58 ms ± 58.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
101 ns ± 9.53 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

提醒一下，只要您存储和查找的元素是可哈希的，这是一个合适的选项。换句话说，它们要么必须是不可变类型，要么是实现的对象__hash__。

解决方案 3：

我知道这是一个非常老的问题，但在 OP 的实际问题“我做错了什么？”中，问题似乎在于他们如何编码以下内容：

仅当元组不在列表中时才采取分支

正如OP所观察到的，这在逻辑上等同于：

IF tuple in list THEN don't take the branch

然而，它完全没有说明应该发生什么IF tuple not in list。特别是，它并没有得出这样的结论：

IF tuple not in list THEN take the branch

因此，OP 的规则从未提及要做什么IF tuple not in list。除此之外，正如其他答案所指出的那样，not in检查对象是否在列表中（或实际上在任何容器中）的正确语法是正确的。例如：

# check if `my_tuple` is not in `my_list`
my_tuple not in my_list

解决方案 4：

也可以使用列表类的count方法：假设我们有一个列表：

x = [10,20,30,40,50]

确认列表中是否有元素（即 10）以及其出现的频率：

if x.count(10):
    print(x.count(10)) 
else:
    print(10," Not in the list")