89

在 python 中,我有一个列表,它应该有一个且只有一个真值(即bool(value) is True)。有没有聪明的方法来检查这个?现在,我只是遍历列表并手动检查:

def only1(l)
    true_found = False
    for v in l:
        if v and not true_found:
            true_found=True
        elif v and true_found:
             return False #"Too Many Trues"
    return true_found

这似乎不优雅,也不是很pythonic。有没有更聪明的方法来做到这一点?

4

17 回答 17

281

不需要进口的一种:

def single_true(iterable):
    i = iter(iterable)
    return any(i) and not any(i)

或者,也许是一个更易读的版本:

def single_true(iterable):
    iterator = iter(iterable)

    # consume from "i" until first true or it's exhausted
    has_true = any(iterator) 

    # carry on consuming until another true value / exhausted
    has_another_true = any(iterator) 

    # True if exactly one true found
    return has_true and not has_another_true

这个:

  • 看起来确保i有任何真正的价值
  • 继续从可迭代的那一点开始寻找,以确保没有其他真正的价值
于 2013-05-28T21:14:08.313 回答
52

这取决于您是否只是在寻找该值True,或者也在寻找其他可以在True逻辑上评估的值(如11or "hello")。如果是前者:

def only1(l):
    return l.count(True) == 1

如果是后者:

def only1(l):
    return sum(bool(e) for e in l) == 1

因为这将在一次迭代中完成计数和转换,而无需构建新列表。

于 2013-05-28T20:54:50.847 回答
46

最冗长的解决方案并不总是最不优雅的解决方案。因此我只添加了一个小的修改(为了节省一些多余的布尔评估):

def only1(l):
    true_found = False
    for v in l:
        if v:
            # a True was found!
            if true_found:
                # found too many True's
                return False 
            else:
                # found the first True
                true_found = True
    # found zero or one True value
    return true_found

以下是一些比较时间:

# file: test.py
from itertools import ifilter, islice

def OP(l):
    true_found = False
    for v in l:
        if v and not true_found:
            true_found=True
        elif v and true_found:
             return False #"Too Many Trues"
    return true_found

def DavidRobinson(l):
    return l.count(True) == 1

def FJ(l):
    return len(list(islice(ifilter(None, l), 2))) == 1

def JonClements(iterable):
    i = iter(iterable)
    return any(i) and not any(i)

def moooeeeep(l):
    true_found = False
    for v in l:
        if v:
            if true_found:
                # found too many True's
                return False 
            else:
                # found the first True
                true_found = True
    # found zero or one True value
    return true_found

我的输出:

$ python -mtimeit -s 'import test; l=[True]*100000' 'test.OP(l)' 
1000000 loops, best of 3: 0.523 usec per loop
$ python -mtimeit -s 'import test; l=[True]*100000' 'test.DavidRobinson(l)' 
1000 loops, best of 3: 516 usec per loop
$ python -mtimeit -s 'import test; l=[True]*100000' 'test.FJ(l)' 
100000 loops, best of 3: 2.31 usec per loop
$ python -mtimeit -s 'import test; l=[True]*100000' 'test.JonClements(l)' 
1000000 loops, best of 3: 0.446 usec per loop
$ python -mtimeit -s 'import test; l=[True]*100000' 'test.moooeeeep(l)' 
1000000 loops, best of 3: 0.449 usec per loop

可以看出,OP 解决方案明显优于此处发布的大多数其他解决方案。正如预期的那样,最好的是那些有短路行为的,尤其是 Jon Clements 发布的解决方案。至少对于True长列表中有两个早期值的情况。

这里同样没有任何True价值:

$ python -mtimeit -s 'import test; l=[False]*100000' 'test.OP(l)' 
100 loops, best of 3: 4.26 msec per loop
$ python -mtimeit -s 'import test; l=[False]*100000' 'test.DavidRobinson(l)' 
100 loops, best of 3: 2.09 msec per loop
$ python -mtimeit -s 'import test; l=[False]*100000' 'test.FJ(l)' 
1000 loops, best of 3: 725 usec per loop
$ python -mtimeit -s 'import test; l=[False]*100000' 'test.JonClements(l)' 
1000 loops, best of 3: 617 usec per loop
$ python -mtimeit -s 'import test; l=[False]*100000' 'test.moooeeeep(l)' 
100 loops, best of 3: 1.85 msec per loop

我没有检查统计显着性,但有趣的是,这次 FJ 提出的方法,尤其是 Jon Clements 提出的方法似乎再次明显优越。

于 2013-05-28T21:16:30.887 回答
23

保留短路行为的单行答案:

from itertools import ifilter, islice

def only1(l):
    return len(list(islice(ifilter(None, l), 2))) == 1

对于相对较早具有两个或更多真值的非常大的可迭代对象,这将比此处的其他替代方法快得多。

ifilter(None, itr)给出一个只产生真实元素的迭代(x如果bool(x)返回则为真实True)。 islice(itr, 2)给出一个只产生 的前两个元素的可迭代对象itr。通过将其转换为列表并检查长度是否等于 1,我们可以验证确实存在一个真实元素,而无需在找到两个元素后检查任何其他元素。

以下是一些时间比较:

  • 设置代码:

    In [1]: from itertools import islice, ifilter
    
    In [2]: def fj(l): return len(list(islice(ifilter(None, l), 2))) == 1
    
    In [3]: def david(l): return sum(bool(e) for e in l) == 1
    
  • 表现出短路行为:

    In [4]: l = range(1000000)
    
    In [5]: %timeit fj(l)
    1000000 loops, best of 3: 1.77 us per loop
    
    In [6]: %timeit david(l)
    1 loops, best of 3: 194 ms per loop
    
  • 不发生短路的大型列表:

    In [7]: l = [0] * 1000000
    
    In [8]: %timeit fj(l)
    100 loops, best of 3: 10.2 ms per loop
    
    In [9]: %timeit david(l)
    1 loops, best of 3: 189 ms per loop
    
  • 小清单:

    In [10]: l = [0]
    
    In [11]: %timeit fj(l)
    1000000 loops, best of 3: 1.77 us per loop
    
    In [12]: %timeit david(l)
    1000000 loops, best of 3: 990 ns per loop
    

因此,sum()对于非常小的列表,该方法更快,但随着输入列表变大,即使不可能短路,我的版本也会更快。当大输入可能发生短路时,性能差异很明显。

于 2013-05-28T21:00:15.537 回答
15

我想获得死灵法师徽章,所以我概括了 Jon Clements 的出色答案,保留了短路逻辑和快速谓词检查的好处。

因此这里是:

N(真) = n

def n_trues(iterable, n=1):
    i = iter(iterable)
    return all(any(i) for j in range(n)) and not any(i)

N(真) <= n:

def up_to_n_trues(iterable, n=1):
    i = iter(iterable)
    all(any(i) for j in range(n))
    return not any(i)

N(真) >= n:

def at_least_n_trues(iterable, n=1):
    i = iter(iterable)
    return all(any(i) for j in range(n))

m <= N(真) <= n

def m_to_n_trues(iterable, m=1, n=1):
    i = iter(iterable)
    assert m <= n
    return at_least_n_trues(i, m) and up_to_n_trues(i, n - m)
于 2014-07-28T15:57:44.317 回答
12
>>> l = [0, 0, 1, 0, 0]
>>> has_one_true = len([ d for d in l if d ]) == 1
>>> has_one_true
True
于 2013-05-28T20:58:39.687 回答
5
if sum([bool(x) for x in list]) == 1

(假设您所有的值都是布尔值。)

将其相加可能会更快

sum(list) == 1   

尽管根据列表中的数据类型,它可能会导致一些问题。

于 2013-05-28T20:55:18.503 回答
5

你可以做:

x = [bool(i) for i in x]
return x.count(True) == 1

或者

x = map(bool, x)
return x.count(True) == 1

基于@JoranBeasley 的方法:

sum(map(bool, x)) == 1
于 2013-05-28T20:55:19.713 回答
4

如果只有一个True,那么Trues 的长度应该是一个:

def only_1(l): return 1 == len(filter(None, l))
于 2013-05-28T21:30:54.197 回答
4

这似乎有效,应该能够处理任何可迭代的,而不仅仅是lists。它尽可能短路以最大限度地提高效率。适用于 Python 2 和 3。

def only1(iterable):
    for i, x in enumerate(iterable):  # check each item in iterable
        if x: break                   # truthy value found
    else:
        return False                  # no truthy value found
    for x in iterable[i+1:]:          # one was found, see if there are any more
        if x: return False            #   found another...
    return True                       # only a single truthy value found

testcases = [  # [[iterable, expected result], ... ]
    [[                          ], False],
    [[False, False, False, False], False],
    [[True,  False, False, False], True],
    [[False, True,  False, False], True],
    [[False, False, False, True],  True],
    [[True,  False, True,  False], False],
    [[True,  True,  True,  True],  False],
]

for i, testcase in enumerate(testcases):
    correct = only1(testcase[0]) == testcase[1]
    print('only1(testcase[{}]): {}{}'.format(i, only1(testcase[0]),
                                             '' if correct else
                                             ', error given '+str(testcase[0])))

输出:

only1(testcase[0]): False
only1(testcase[1]): False
only1(testcase[2]): True
only1(testcase[3]): True
only1(testcase[4]): True
only1(testcase[5]): False
only1(testcase[6]): False
于 2013-05-29T02:00:30.507 回答
3

@JonClements` 解决方案最多扩展到 N 个真值

# Extend any() to n true values
def _NTrue(i, n=1):
    for x in xrange(n):
        if any(i): # False for empty
            continue
        else:
            return False
    return True

def NTrue(iterable, n=1):
    i = iter(iterable)
    return any(i) and not _NTrue(i, n)

编辑:更好的版本

def test(iterable, n=1): 
    i = iter(iterable) 
    return sum(any(i) for x in xrange(n+1)) <= n 

edit2:包括至少 m 个 True最多 n 个 True

def test(iterable, n=1, m=1): 
    i = iter(iterable) 
    return  m <= sum(any(i) for x in xrange(n+1)) <= n
于 2013-05-28T22:05:38.990 回答
2
def only1(l)
    sum(map(lambda x: 1 if x else 0, l)) == 1

说明:该map函数将一个列表映射到另一个列表,执行True => 1False => 0。我们现在有一个 0 和 1 的列表,而不是 True 或 False。现在我们简单地对这个列表求和,如果它是 1,那么只有一个 True 值。

于 2013-06-03T04:57:50.127 回答
1

为了完整起见并演示 Python 控制流在 for 循环迭代中的高级使用,可以避免在接受的答案中进行额外的计算,从而稍微加快速度。:

def one_bool_true(iterable):
    it = iter(iterable)
    for i in it:
        if i:
            break
    else:            #no break, didn't find a true element
        return False
    for i in it:     # continue consuming iterator where left off
        if i: 
            return False
    return True      # didn't find a second true.

上面的简单控制流利用了 Python 复杂的循环特性:else. 语义是,如果您完成对正在使用的迭代器的迭代而没有break退出它,那么您将进入该else块。

这是公认的答案,它使用了更多的会计信息。

def only1(l):
    true_found = False
    for v in l:
        if v:
            # a True was found!
            if true_found:
                # found too many True's
                return False 
            else:
                # found the first True
                true_found = True
    # found zero or one True value
    return true_found

计时这些:

import timeit
>>> min(timeit.repeat(lambda: one_bool_true([0]*100 + [1, 1])))
13.992251592921093
>>> min(timeit.repeat(lambda: one_bool_true([1, 1] + [0]*100)))
2.208037032979064
>>> min(timeit.repeat(lambda: only1([0]*100 + [1, 1])))
14.213872335107908
>>> min(timeit.repeat(lambda: only1([1, 1] + [0]*100)))
2.2482982632641324
>>> 2.2482/2.2080
1.0182065217391305
>>> 14.2138/13.9922
1.0158373951201385

所以我们看到接受的答案需要更长的时间(略超过百分之一半)。

自然地,使用用 C 编写的内置any函数要快得多(请参阅 Jon Clement 的实现答案 - 这是简短形式):

>>> min(timeit.repeat(lambda: single_true([0]*100 + [1, 1])))
2.7257133318785236
>>> min(timeit.repeat(lambda: single_true([1, 1] + [0]*100)))
2.012824866380015
于 2016-01-25T18:49:14.020 回答
0

这是你要找的吗?

sum(l) == 1
于 2013-05-29T15:28:39.797 回答
0
import collections

def only_n(l, testval=True, n=1):
    counts = collections.Counter(l)
    return counts[testval] == n

线性时间。使用内置的 Counter 类,您应该使用它来检查计数。

重新阅读您的问题,看起来您实际上想检查是否只有一个真实值,而不是一个True值。尝试这个:

import collections

def only_n(l, testval=True, coerce=bool, n=1):
    counts = collections.Counter((coerce(x) for x in l))
    return counts[testval] == n

虽然您可以获得更好的最佳情况性能,但没有什么比最坏情况性能更好。这也是简短易读的。

这是针对最佳情况性能优化的版本:

import collections
import itertools

def only_n(l, testval=True, coerce=bool, n=1):
    counts = collections.Counter()
    def iterate_and_count():
        for x in itertools.imap(coerce,l):
            yield x
            if x == testval and counts[testval] > n:
               break
    counts.update(iterate_and_count())
    return counts[testval] == n

最坏情况下的性能很高k(如O(kn+c)),但它是完全一般的。

这是一个尝试性能的ideone:http: //ideone.com/ZRrv2m

于 2013-06-07T18:40:47.547 回答
0

关于什么:

len([v for v in l if type(v) == bool and v])

如果您只想计算布尔 True 值。

于 2017-11-03T11:06:50.420 回答
0

这里的东西应该适用于任何真实的东西,尽管它没有短路。我在寻找一种禁止互斥论点的干净方法时发现了它:

if sum(1 for item in somelist if item) != 1:
    raise ValueError("or whatever...")
于 2016-08-07T00:08:26.873 回答