Python可以测试列表中多个值的成员资格吗？

如何解决Python可以测试列表中多个值的成员资格吗？

| 我想测试列表中是否有两个或多个值具有成员资格，但是我得到了意外的结果：

>>> \'a\',\'b\' in [\'b\',\'a\',\'foo\',\'bar\']
(\'a\',True)

那么，Python可以一次在列表中测试多个值的成员资格吗？ 结果是什么意思？     

解决方法

        这可以满足您的要求，并且几乎可以在所有情况下使用：

>>> all(x in [\'b\',\'a\',\'foo\',\'bar\'] for x in [\'a\',\'b\'])
True

表达式

\'a\',\'b\' in [\'b\',\'bar\']

不能按预期工作，因为Python将其解释为元组：

>>> \'a\',\'b\'
(\'a\',\'b\')
>>> \'a\',5 + 2
(\'a\',7)
>>> \'a\',\'x\' in \'xerxes\'
(\'a\',True)

其他选择 还有其他执行此测试的方法，但是它们不适用于许多不同种类的输入。正如Kabie指出的那样，您可以使用集合解决此问题...

>>> set([\'a\',\'b\']).issubset(set([\'a\',\'b\',\'bar\']))
True
>>> {\'a\',\'b\'} <= {\'a\',\'bar\'}
True

...有时：

>>> {\'a\',[\'b\']} <= {\'a\',[\'b\'],\'bar\'}
Traceback (most recent call last):
  File \"<stdin>\",line 1,in <module>
TypeError: unhashable type: \'list\'

只能使用可哈希元素创建集。但是生成器表达式“ 6”可以处理几乎所有容器类型。唯一的要求是“ 7”是可重复的（即不是生成器）。

items

可以是任何迭代。

>>> container = [[\'b\'],\'bar\']
>>> items = (i for i in (\'a\',[\'b\']))
>>> all(x in [[\'b\'],\'bar\'] for x in items)
True

速度测试 在许多情况下，子集测试的速度将快于

all

，但差异并不令人震惊-除非问题无关紧要，因为集合不是选项，否则差异并不令人震惊。仅将列表转换为集合是为了进行这样的测试并不总是值得的。而且，将生成器转换为集合有时会非常浪费，将程序减慢了多个数量级。 这里有一些基准用于说明。当

container

和

items

都较小时，最大的区别就出现了。在这种情况下，子集方法要快一个数量级：

>>> smallset = set(range(10))
>>> smallsubset = set(range(5))
>>> %timeit smallset >= smallsubset
110 ns ± 0.702 ns per loop (mean ± std. dev. of 7 runs,10000000 loops each)
>>> %timeit all(x in smallset for x in smallsubset)
951 ns ± 11.5 ns per loop (mean ± std. dev. of 7 runs,1000000 loops each)

这看起来有很大的不同。但是只要

container

是一个集合，

all

仍然可以在更大的比例下完美使用：

>>> bigset = set(range(100000))
>>> bigsubset = set(range(50000))
>>> %timeit bigset >= bigsubset
1.14 ms ± 13.9 µs per loop (mean ± std. dev. of 7 runs,1000 loops each)
>>> %timeit all(x in bigset for x in bigsubset)
5.96 ms ± 37 µs per loop (mean ± std. dev. of 7 runs,100 loops each)

使用子集测试仍然更快，但在这种规模下仅提高了约5倍。速度的提高归功于Python对

set

的快速支持（由

c

支持），但是两种情况下的基本算法都是相同的。 如果由于其他原因，您的“ 8”已经存储在列表中，那么在使用子集测试方法之前，您必须将其转换为集合。然后加速降到大约2.5倍：

>>> %timeit bigset >= set(bigsubseq)
2.1 ms ± 49.2 µs per loop (mean ± std. dev. of 7 runs,100 loops each)

而且，如果您的

container

是一个序列，并且需要首先进行转换，则加速会更小：

>>> %timeit set(bigseq) >= set(bigsubseq)
4.36 ms ± 31.4 µs per loop (mean ± std. dev. of 7 runs,100 loops each)

唯一令人沮丧的缓慢结果是，当我们将get7ѭ作为序列离开时：

>>> %timeit all(x in bigseq for x in bigsubseq)
184 ms ± 994 µs per loop (mean ± std. dev. of 7 runs,10 loops each)

当然，只有在必须的情况下，我们才会这样做。如果ѭ25中的所有项目都是可哈希的，那么我们将改为：

>>> %timeit bigset = set(bigseq); all(x in bigset for x in bigsubseq)
7.24 ms ± 78 µs per loop (mean ± std. dev. of 7 runs,100 loops each)

这仅比其他方法（

set(bigseq) >= set(bigsubseq)

，在4.36处的出价高）快1.66倍。 因此，子集测试通常更快，但幅度并不惊人。另一方面，让我们看一下

all

更快的时间。如果

items

长为一千万个值，并且可能具有不在

container

中的值怎么办？

>>> %timeit hugeiter = (x * 10 for bss in [bigsubseq] * 2000 for x in bss); set(bigset) >= set(hugeiter)
13.1 s ± 167 ms per loop (mean ± std. dev. of 7 runs,1 loop each)
>>> %timeit hugeiter = (x * 10 for bss in [bigsubseq] * 2000 for x in bss); all(x in bigset for x in hugeiter)
2.33 ms ± 65.2 µs per loop (mean ± std. dev. of 7 runs,100 loops each)

在这种情况下，将发电机转换为发电机组非常浪费。

set

构造函数必须消耗整个生成器。但是ѭ10的短路行为确保了仅消耗一小部分发电机，因此它比子集测试快四个数量级。 诚然，这是一个极端的例子。但正如它所显示的，您不能假设一种方法在任何情况下都更快。 结果 在大多数情况下，至少将7中的所有元素都可哈希化，将其转化为一个集合是值得的。那是因为集合的ѭ35是O（1），而序列的ѭ35是O（n）。 另一方面，有时仅值得使用子集测试。如果您的测试项目已经存储在集中，则绝对可以这样做。否则，“ 10”仅会慢一点，并且不需要任何其他存储。它也可以与大型项目生成器一起使用，在这种情况下有时可以大大提高速度。     ,        另一种方法是：

>>> set([\'a\',\'b\']).issubset( [\'b\',\'bar\'] )
True

    ,        我很确定ѭ35的优先级高于ѭ40的优先级，因此您的语句被解释为

\'a\',(\'b\' in [\'b\' ...])

，由于数组中有in43。，因此它的计算结果为

\'a\',True

。 请参阅先前的答案以了解如何做您想做的事情。     ,        Python解析器将该语句评估为元组，其中第一个值为

\'a\'

，第二个值为表达式

\'b\' in [\'b\',\'bar\']

（其值为to46ѭ）。 您可以编写一个简单的函数来执行您想要的操作，但是：

def all_in(candidates,sequence):
    for element in candidates:
        if element not in sequence:
            return False
    return True

并这样称呼：

>>> all_in((\'a\',\'b\'),[\'b\',\'bar\'])
True

    ,        如果您要检查所有输入匹配项，

>>> all(x in [\'b\',\'b\'])

如果您想检查至少一场比赛，

>>> any(x in [\'b\',\'b\'])

    ,

[x for x in [\'a\',\'b\'] if x in [\'b\',\'bar\']]

我认为这比所选答案更好的原因是，您确实不需要调用\'all（）\'函数。在IF语句中，空列表的值为False，非空列表的值为True。

if [x for x in [\'a\',\'bar\']]:
    ...Do something...

例：

>>> [x for x in [\'a\',\'bar\']]
[\'a\',\'b\']
>>> [x for x in [\'G\',\'F\'] if x in [\'b\',\'bar\']]
[]

    ,        我想说，我们甚至可以将那些方括号排除在外。

array = [\'b\',\'bar\']
all([i in array for i in \'a\',\'b\'])

    ,        这里给出的两个答案都不会处理重复的元素。例如，如果要测试[1,2,2]是否是[1,3,4]的子列表，则两者都将返回True。那可能就是您的意思，但是我只是想澄清一下。 如果要为[1,4]中的[1,2]返回false，则需要对两个列表进行排序，并在每个列表上检查带有移动索引的每个项目。 for循环稍微复杂一点。     ,        没有lambdas，怎么能成为pythonic！ ..不用认真对待..但是这种方式也可以：

orig_array = [ ..... ]
test_array = [ ... ]

filter(lambda x:x in test_array,orig_array) == test_array

如果要测试数组中是否包含任何值，请省略结尾部分：

filter(lambda x:x in test_array,orig_array)