Comment puis-je vérifier que la liste a un et un seul truthy valeur?

Le niveau le plus détaillé de la solution n'est pas toujours le plus unelegant solution. Donc j'ajoute juste une modification mineure (dans l'ordre pour sauver un peu redondant boolean évaluations):

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

---

Voici quelques timings pour la comparaison:

# 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

Ma sortie:

$ 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

Comme on le voit, l'OP solution est nettement mieux que la plupart des autres solutions posté ici. Comme prévu, les meilleurs sont ceux de court-circuit comportement, surtout que la solution posté par Jon Clements. Au moins pour le cas de deux au début de la True valeurs dans une liste.

Ici le même pour ne True valeur:

$ 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

Je n'ai pas vérifier la signification statistique, mais c'est intéressant, cette fois, les approches proposées par F. J., et surtout celle de Jon Clements apparaître de nouveau à être nettement supérieure.

OriginalL'auteur moooeeeep

Cela dépend si vous êtes juste à la recherche de la valeur True ou sont aussi à la recherche de valeurs qui permettrait d'évaluer à True logiquement (comme 11 ou "hello"). Si l'ancien:

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

Si ce dernier:

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

ce qui permettrait de faire les deux, le comptage et la conversion en une seule itération, sans avoir à construire une nouvelle liste.

OriginalL'auteur David Robinson

Je voulais gagner le nécromancien badge, donc j'ai généralisé le Jon Clements excellente réponse, en préservant les avantages de court-circuiter la logique et rapide prédicat de la vérification avec toute et tous.

Donc, ici, est:

N(trues) = n

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

N(trues) <= 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(trues) >= n:

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

m <= N(trues) <= 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)

OriginalL'auteur Antti Haapala

Que vous pouvez faire:

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

Ou

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

Bâtiment sur @JoranBeasley de la méthode:

sum(map(bool, x)) == 1

OriginalL'auteur karthikr

Cela semble fonctionner et devrait être en mesure de gérer n'importe quel itérable, pas seulementlists. Il les courts-circuits, chaque fois que possible afin de maximiser l'efficacité. Fonctionne dans les deux Python 2 et 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])))

De sortie:

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

OriginalL'auteur martineau

@JonClements solution étendue pour au plus N valeurs Vraies:

# 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)

edit: meilleure version

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

edit2: inclure au moins m de True et au plus n de True

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

OriginalL'auteur Nisan.H

À des fins d'exhaustivité, et de démontrer l'utilisation avancée de Python de contrôle de flux pour pour tour de boucle, on peut éviter le supplément de la comptabilité de la accepté de répondre, faisant à ceci un peu plus rapide.:

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.

Au-dessus du flux de contrôle simple rend l'utilisation de Python est sophistiqué fonctionnalité de boucles: la else. La sémantique est que si vous avez fini de parcourir l'itérateur que vous consommez sans break-ing hors d'elle, vous entrez alors dans le else bloc.

Voici la accepté de répondre, qui utilise un peu plus de la comptabilité.

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

de temps ces:

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

Nous voyons donc que l'on a accepté la réponse est un peu plus longue (un peu plus d'un an et demi de un pour cent).

Naturellement, en utilisant le haut -any, écrit en C, est beaucoup plus rapide (voir Jon Clement de réponse pour la mise en œuvre - c'est la forme courte):

>>> min(timeit.repeat(lambda: single_true([0]*100 + [1, 1])))
2.7257133318785236
>>> min(timeit.repeat(lambda: single_true([1, 1] + [0]*100)))
2.012824866380015

OriginalL'auteur Aaron Hall

import collections

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

Temps linéaire. Utilise le Compteur intégré de classe, qui est ce que vous devriez utiliser pour vérifier le compte.

Re-lecture de votre question, il semble que vous voulez réellement pour vérifier qu'il n'est qu'un truthy valeur, plutôt qu'un True valeur. Essayez ceci:

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

Alors que vous pouvez obtenir mieux dans le meilleur des cas les performances, rien n'a mieux pour le pire des cas la performance. C'est aussi court et facile à lire.

Voici une version optimisée pour de meilleures performances:

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

Le pire des cas, la performance a une forte k (comme dans O(kn+c)), mais il est complètement général.

Voici un ideone à expérimenter avec des performances: http://ideone.com/ZRrv2m

OriginalL'auteur Marcin

Ce sujet:

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

Si vous ne voulez compter boolean True valeurs.

OriginalL'auteur Radek Svoboda