Contando o número de True Booleans em uma lista Python

Eu tenho uma lista de booleanos:

[True, True, False, False, False, True]

e estou procurando uma maneira de contar o número da Truelista (por isso, no exemplo acima, quero que o retorno seja 3). Encontrei exemplos de como procurar o número de ocorrências de elementos específicos, mas há mais maneira eficiente de fazer isso, pois estou trabalhando com booleanos? Estou pensando em algo análogo a allou any.

Trueé igual a 1.

>>> sum([True, True, False, False, False, True])
3

listtem um countmétodo:

>>> [True,True,False].count(True)
2

Isso é realmente mais eficiente do que sum, além de ser mais explícito sobre a intenção, portanto não há razão para usar sum:

In [1]: import random

In [2]: x = [random.choice([True, False]) for i in range(100)]

In [3]: %timeit x.count(True)
970 ns ± 41.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [4]: %timeit sum(x)
1.72 µs ± 161 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Se você está preocupado apenas com a constante True, um simples sumé bom. No entanto, lembre-se de que no Python outros valores também são avaliados True. Uma solução mais robusta seria usar o boolbuiltin:

>>> l = [1, 2, True, False]
>>> sum(bool(x) for x in l)
3

ATUALIZAÇÃO: Aqui está outra solução igualmente robusta que tem a vantagem de ser mais transparente:

>>> sum(1 for x in l if x)
3

Curiosidades PS Python: True poderia ser verdade sem ser 1. Aviso: não tente fazer isso no trabalho!

>>> True = 2
>>> if True: print('true')
... 
true
>>> l = [True, True, False, True]
>>> sum(l)
6
>>> sum(bool(x) for x in l)
3
>>> sum(1 for x in l if x)
3

Muito mais maldade:

True = False

Você pode usar sum():

>>> sum([True, True, False, False, False, True])
3

Por uma questão de completude ( sumgeralmente é preferível), eu queria mencionar que também podemos usar filterpara obter os valores verdadeiros. No caso usual, filteraceita uma função como o primeiro argumento, mas se você a passar None, ela filtrará todos os valores "verdade". Esse recurso é um tanto surpreendente, mas está bem documentado e funciona em Python 2 e 3.

A diferença entre as versões é que no Python 2 filterretorna uma lista, para que possamos usar len:

>>> bool_list = [True, True, False, False, False, True]
>>> filter(None, bool_list)
[True, True, True]
>>> len(filter(None, bool_list))
3

Mas no Python 3, filterretorna um iterador, portanto não podemos usá-lo lene, se queremos evitar o uso sum(por qualquer motivo), precisamos recorrer à conversão do iterador em uma lista (o que torna muito menos bonito):

>>> bool_list = [True, True, False, False, False, True]
>>> filter(None, bool_list)
<builtins.filter at 0x7f64feba5710>
>>> list(filter(None, bool_list))
[True, True, True]
>>> len(list(filter(None, bool_list)))
3

Depois de ler todas as respostas e comentários sobre essa pergunta, pensei em fazer um pequeno experimento.

I gerados 50.000 booleans aleatórios e chamado sume countsobre eles.

Aqui estão meus resultados:

>>> a = [bool(random.getrandbits(1)) for x in range(50000)]
>>> len(a)
50000
>>> a.count(False)
24884
>>> a.count(True)
25116
>>> def count_it(a):
...   curr = time.time()
...   counting = a.count(True)
...   print("Count it = " + str(time.time() - curr))
...   return counting
... 
>>> def sum_it(a):
...   curr = time.time()
...   counting = sum(a)
...   print("Sum it = " + str(time.time() - curr))
...   return counting
... 
>>> count_it(a)
Count it = 0.00121307373046875
25015
>>> sum_it(a)
Sum it = 0.004102230072021484
25015

Só para ter certeza, repeti várias vezes:

>>> count_it(a)
Count it = 0.0013530254364013672
25015
>>> count_it(a)
Count it = 0.0014507770538330078
25015
>>> count_it(a)
Count it = 0.0013344287872314453
25015
>>> sum_it(a)
Sum it = 0.003480195999145508
25015
>>> sum_it(a)
Sum it = 0.0035257339477539062
25015
>>> sum_it(a)
Sum it = 0.003350496292114258
25015
>>> sum_it(a)
Sum it = 0.003744363784790039
25015

E como você pode ver, counté 3 vezes mais rápido que sum. Então, eu sugeriria usar countcomo fiz count_it.

Versão Python: 3.6.7
Núcleos da CPU: 4
Tamanho da RAM: 16 GB
SO: Ubuntu 18.04.1 LTS

É mais seguro percorrer boolprimeiro. Isso é feito facilmente:

>>> sum(map(bool,[True, True, False, False, False, True]))
3

Então, você capturará tudo o que o Python considerar Verdadeiro ou Falso no intervalo apropriado:

>>> allTrue=[True, not False, True+1,'0', ' ', 1, [0], {0:0}, set([0])]
>>> list(map(bool,allTrue))
[True, True, True, True, True, True, True, True, True]

Se preferir, você pode usar uma compreensão:

>>> allFalse=['',[],{},False,0,set(),(), not True, True-1]
>>> [bool(i) for i in allFalse]
[False, False, False, False, False, False, False, False, False]

Eu prefiro len([b for b in boollist if b is True])(ou o equivalente da expressão geradora), pois é bastante auto-explicativo. Menos 'mágico' do que a resposta proposta por Ignacio Vazquez-Abrams.

Como alternativa, você pode fazer isso, que ainda assume que o bool é convertível em int, mas não faz suposições sobre o valor de True: ntrue = sum(boollist) / int(True)