问题描述：

我使用以下方法检查是否item在my_list：

if item in my_list:
    print("Desired item is in list")

“ if item in my_list:”是在列表中查找项目的最“python化”的方式吗？

重新打开编辑：这个问题被认为是重复的，但我并不完全相信：这里这个问题大致是“在列表中查找元素的最Python方式是什么”。并且问题的第一个答案在所有 Python 方式中都非常广泛。

而在链接重复问题及其对应的答案中，重点大致仅限于 Python 中的“in”关键字。我认为与当前问题相比，它确实存在局限性。

我认为对当前问题的回答比提出的重复问题/答案的答案更相关、更详细。

解决方案 1：

至于您的第一个问题：“ if item is in my_list:”完全没问题，如果item等于 中的一个元素，则应该可以工作my_list。该项目必须与列表中的项目完全"abc"匹配。例如，和"ABC"不匹配。浮点值尤其可能不准确。例如，1 - 1/3 != 2/3。

至于您的第二个问题：在列表中“查找”事物实际上有几种可能的方法。

检查里面是否有东西

这是您描述的用例：检查某个东西是否在列表中。如您所知，您可以使用in运算符来实现这一点：

3 in [1, 2, 3] # => True

过滤集合

即查找序列中满足特定条件的所有元素。您可以使用列表推导或生成器表达式来实现这一点：

matches = [x for x in lst if fulfills_some_condition(x)]
matches = (x for x in lst if x > 6)

后者将返回一个生成器，你可以将其想象成一种惰性列表，只有在迭代时才会构建。顺便说一句，第一个完全等同于

matches = filter(fulfills_some_condition, lst)

在 Python 2 中。在这里您可以看到高阶函数在工作。在 Python 3 中，filter不返回列表，而是返回类似生成器的对象。

查找第一次出现的情况

如果你只想要第一个符合条件的东西（但你还不知道它是什么），那么使用 for 循环就可以了（也可以使用子句else，但这并不为人所知）。你也可以使用

next(x for x in lst if ...)

这将返回第一个匹配项，StopIteration如果未找到任何匹配项，则引发。或者，您可以使用

next((x for x in lst if ...), [default value])

查找项目的位置

对于列表，index如果您想知道列表中某个元素的位置，那么这种方法有时也会很有用：

[1,2,3].index(2) # => 1
[1,2,3].index(4) # => ValueError

但是，请注意，如果有重复项，.index则始终返回最低索引：......

[1,2,3,2].index(2) # => 1

如果有重复并且您想要所有索引，那么您可以使用enumerate()：

[i for i,x in enumerate([1,2,3,2]) if x==2] # => [1, 3]

解决方案 2：

如果您想查找一个元素或None使用默认值，则如果在列表中找不到该项目，next它将不会引发：StopIteration

first_or_default = next((x for x in lst if ...), None)

解决方案 3：

虽然 Niklas B. 的回答非常全面，但是当我们想要在列表中查找某个项目时，获取其索引有时很有用：

next((i for i, x in enumerate(lst) if [condition on x]), [default value])

解决方案 4：

查找第一次出现的情况

itertools 中有一个解决方法：

def first_true(iterable, default=False, pred=None):
    """Returns the first true value in the iterable.

    If no true value is found, returns *default*

    If *pred* is not None, returns the first item
    for which pred(item) is true.

    """
    # first_true([a,b,c], x) --> a or b or c or x
    # first_true([a,b], x, f) --> a if f(a) else b if f(b) else x
    return next(filter(pred, iterable), default)

例如，以下代码查找列表中的第一个奇数：

>>> first_true([2,3,4,5], None, lambda x: x%2==1)
3  

您可以复制/粘贴或安装more-itertools

pip3 install more-itertools

其中已经包含了该配方。

解决方案 5：

另一种选择：您可以使用 检查某个项目是否在列表中if item in list:，但这是 O(n) 阶。如果您要处理大型项目列表，并且您需要知道某个项目是否是列表的成员，则可以先将列表转换为集合，然后利用恒定时间集合查找：

my_set = set(my_list)
if item in my_set:  # much faster on average than using a list
    # do something

在每种情况下这都不会是正确的解决方案，但在某些情况下这可能会给你带来更好的性能。

请注意，使用创建集合的时间复杂度set(my_list)也是 O(n)，因此如果您只需要执行一次，那么这种方式并不会更快。但是，如果您需要反复检查成员资格，那么在初始集合创建之后，每次查找的时间复杂度都将是 O(1)。

解决方案 6：

定义和用法

该count()方法返回具有指定值的元素的数量。

句法

list.count(value)

例子：

fruits = ['apple', 'banana', 'cherry']

x = fruits.count("cherry")

问题示例：

item = someSortOfSelection()

if myList.count(item) >= 1 :

    doMySpecialFunction(item)

解决方案 7：

处理字符串列表时，您可能需要使用以下两种可能的搜索之一：

1. 如果列表元素等于某个项目（'example' 在 ['one','example','two'] 中）：

if item in your_list: some_function_on_true()

'ex' 在 ['one','ex','two'] => True

'ex_1' 在 ['one','ex','two'] => False

1. 如果列表元素就像一个项目（'ex' 在 ['one,'example','two'] 中或 'example_1' 在 ['one','example','two'] 中）：

matches = [el for el in your_list if item in el]

或者

matches = [el for el in your_list if el in item]

然后只要根据需要检查len(matches)或阅读它们即可。

解决方案 8：

如果您要检查一次收集品中是否存在值，那么使用“in”运算符就可以了。但是，如果您要检查多次，那么我建议使用 bisect 模块。请记住，使用 bisect 模块必须对数据进行排序。因此，您只需对数据进行一次排序，然后就可以使用 bisect。在我的计算机上使用 bisect 模块比使用“in”运算符快 12 倍左右。

以下是使用 Python 3.8 及以上版本语法的代码示例：

import bisect
from timeit import timeit

def bisect_search(container, value):
    return (
      (index := bisect.bisect_left(container, value)) < len(container) 
      and container[index] == value
    )

data = list(range(1000))
# value to search
true_value = 666
false_value = 66666

# times to test
ttt = 1000

print(f"{bisect_search(data, true_value)=} {bisect_search(data, false_value)=}")

t1 = timeit(lambda: true_value in data, number=ttt)
t2 = timeit(lambda: bisect_search(data, true_value), number=ttt)

print("Performance:", f"{t1=:.4f}, {t2=:.4f}, diffs {t1/t2=:.2f}")

输出：

bisect_search(data, true_value)=True bisect_search(data, false_value)=False
Performance: t1=0.0220, t2=0.0019, diffs t1/t2=11.71

解决方案 9：

for循环

def for_loop(l, target):
    for i in l:
        if i == target:
            return i
    return None


l = [1, 2, 3, 4, 5]
print(for_loop(l, 0))
print(for_loop(l, 1))
# None
# 1

下一个

def _next(l, target):
    return next((i for i in l if i == target), None)


l = [1, 2, 3, 4, 5]
print(_next(l, 0))
print(_next(l, 1))
# None
# 1

more_itertools

more_itertools.first_true(iterable, default=None, pred=None)

安装

pip install more-itertools

或者直接使用

def first_true(iterable, default=None, pred=None):
    return next(filter(pred, iterable), default)

from more_itertools import first_true

l = [1, 2, 3, 4, 5]
print(first_true(l, pred=lambda x: x == 0))
print(first_true(l, pred=lambda x: x == 1))
# None
# 1

比较

import timeit
import more_itertools


def for_loop():
    for i in range(10000000):
        if i == 9999999:
            return i
    return None


def _next():
    return next((i for i in range(10000000) if i == 9999999), None)


def first_true():
    return more_itertools.first_true(range(10000000), pred=lambda x: x == 9999999)


def first_true_2():
    return more_itertools.first_true((i for i in range(10000000) if i == 9999999))


print(timeit.timeit(for_loop, number=10))
print(timeit.timeit(_next, number=10))
print(timeit.timeit(first_true, number=10))
print(timeit.timeit(first_true_2, number=10))
# 2.7730861
# 3.6409407000000003
# 10.869996399999998
# 3.8214487000000013

解决方案 10：

您不必使用list.index(x)which 返回 x 在列表中的索引（如果在列表中找到 x）或返回一条#ValueError消息（如果未找到 x），而是使用list.count(x)which 返回列表中 x 的出现次数（验证 x 确实在列表中），否则返回 0（如果不存在 x）。很酷的一点是，count()当未找到 x 时，它不会破坏您的代码或要求您抛出异常。

解决方案 11：

你说在我多次尝试中，可能有空格和换行符干扰，这就是我给你这个解决方案的原因。

myList=[" test","ok","ok1"]
item = "test"#someSortOfSelection()
if  True in list(map(lambda el : item in el ,myList)):
    doMySpecialFunction(item)

解决方案 12：

检查字符串列表的项目中是否有多余的/不需要的空格。这是导致无法找到项目的原因。

解决方案 13：

 lstr=[1, 2, 3]
 lstr=map(str,lstr)
 r=re.compile('^(3){1}')
 results=list(filter(r.match,lstr))
 print(results)

解决方案 14：

in也适用于list()s dict()：

a = [ {"a":1}, {"b":1, "c":1} ]

b = {"c":1 , "b":1} # <-- No matter the order
    
if b in a: 
    print("b is in a")

至少在 Python 3.8.10 中，无论顺序如何