至于您的第一个问题：“如果item在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中。在这里你可以看到高阶函数在起作用。在Python3中，过滤器不返回列表，而是返回类似生成器的对象。

查找第一个事件

如果你只想要第一个匹配条件的东西（但你还不知道它是什么），可以使用for循环（也可以使用else子句，这不是很有名）。您也可以使用

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

如果没有找到匹配项，则返回第一个匹配项或引发StopIteration。或者，您可以使用

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

查找项目的位置

对于列表，如果您想知道某个元素在列表中的位置，也可以使用索引方法：

[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]

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

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

检查字符串列表中的项目中是否没有额外的/不需要的空白。这是一个可能会干扰解释找不到项目的原因。

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

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

查找第一个事件

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  

您可以复制/粘贴它或安装更多itertools

pip3 install more-itertools

其中该配方已经包括在内。

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

如果列表元素等于项（“示例”位于[“一个”，“示例”，“两个”]）：如果项目在您的列表中：some_function_on_true（）['one'，'ex'，'wo']=>真['one'，'ex'，'wo'中的'ex_1'=>False如果列表元素像一个项目（'ex'在['one，'example'，'wo']或'example_1'在[“一个”，“示例”，“两个”]）：matches=[el for el in your_list if item in el]或matches=[el for el in your_list if el in item]然后只需检查len（匹配项）或根据需要读取它们。

另一种选择是：您可以使用列表中的if项检查列表中的某个项是否存在，但这是顺序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）。

如果在列表中找到x，则使用list.index（x）返回x的索引，如果找不到x，则返回#ValueError消息，您可以使用list.count（x）来返回列表中x的出现次数（验证x是否确实在列表中），否则返回0（如果没有x）。count（）很酷的一点是它不会破坏代码，也不会在找不到x时要求抛出异常。

定义和使用

count（）方法返回具有指定值的元素数。

语法

list.count(value)

例子：

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

x = fruits.count("cherry")

问题示例：

item = someSortOfSelection()

if myList.count(item) >= 1 :

    doMySpecialFunction(item)

如果您要检查一次集合中是否存在值，那么可以使用“in”运算符。然而，如果您要检查不止一次，那么我建议使用平分模块。请记住，使用平分模块数据必须进行排序。因此，您对数据进行一次排序，然后可以使用二等分。在我的机器上使用平分模块比使用“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

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

你说在我的几次试验中，可能有空白和换行干扰。这就是为什么我给你这个解决方案。

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

用于_操作

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

next

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.first_true（可迭代，默认值=无，pred=无）

安装

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

在与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中，无论顺序如何