How can I check that a list has one and only one truthy value?

In python, I have a list that should have one and only one truthy value (that is, bool(value) is True). Is there a clever way to check for this? Right now, I am just iterating across the list and manually checking:

    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

This seems inelegant and not very pythonic. Is there a cleverer way to do this?

The most verbose solution is not always the most unelegant solution. Therefore I add just a minor modification (in order to save some redundant boolean evaluations):

    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

Here are some timings for comparison:

    # 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

My output:

    $ 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

As can be seen, the OP solution is significantly better than most other solutions posted here. As expected, the best ones are those with short circuit behavior, especially that solution posted by Jon Clements. At least for the case of two early True values in a long list.

Here the same for no True value at all:

    $ 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

I did not check the statistical significance, but interestingly, this time the approaches suggested by F.J. and especially that one by Jon Clements again appear to be clearly superior.

From: stackoverflow.com/q/16801322

Back to homepage or read more recommendations: