Zählen der Anzahl der True Booleans in einer Python-Liste

Ich habe eine Liste von Booleschen:

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

und ich suche nach einer Möglichkeit, die Anzahl der Vorkommen Truein der Liste zu zählen (im obigen Beispiel möchte ich, dass die Rückgabe erfolgt 3). Ich habe Beispiele für die Suche nach der Anzahl der Vorkommen bestimmter Elemente gefunden, aber es gibt noch mehr Effizienter Weg, da ich mit Booleanern arbeite? Ich denke an etwas Analoges zu alloder any.

Trueist gleich 1.

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

listhat eine countMethode:

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

Dies ist tatsächlich effizienter als sumund expliziter in Bezug auf die Absicht, sodass es keinen Grund gibt, Folgendes zu verwenden 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)

Wenn Sie sich nur mit der Konstante befassen True, ist eine einfache sumin Ordnung. Beachten Sie jedoch, dass in Python auch andere Werte ausgewertet werden True. Eine robustere Lösung wäre die Verwendung der booleingebauten:

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

UPDATE: Hier ist eine weitere ähnlich robuste Lösung, die den Vorteil hat, transparenter zu sein:

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

PS Python Lappalien: True könnte wahr sein , ohne 1. Warnung zu sein: nicht versuchen , diese bei der Arbeit!

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

Viel böser:

True = False

Sie können verwenden sum():

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

Nur der Vollständigkeit halber ( sumist normalerweise vorzuziehen) wollte ich erwähnen, dass wir auch verwenden können filter, um die wahrheitsgemäßen Werte zu erhalten. Akzeptiert im Normalfall filtereine Funktion als erstes Argument, aber wenn Sie sie übergeben None, wird nach allen "wahrheitsgemäßen" Werten gefiltert. Diese Funktion ist etwas überraschend, aber gut dokumentiert und funktioniert sowohl in Python 2 als auch in Python 3.

Der Unterschied zwischen den Versionen besteht darin, dass in Python 2 filtereine Liste zurückgegeben wird, sodass wir Folgendes verwenden können len:

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

In Python 3 wird jedoch filterein Iterator zurückgegeben, sodass wir ihn nicht verwenden lenkönnen. Wenn wir die Verwendung sum(aus irgendeinem Grund) vermeiden möchten, müssen wir den Iterator in eine Liste konvertieren (was dies viel weniger hübsch macht):

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

Nachdem ich alle Antworten und Kommentare zu dieser Frage gelesen hatte, dachte ich an ein kleines Experiment.

Ich erzeugen 50.000 zufällig booleans und genannt sumund countauf sie.

Hier sind meine Ergebnisse:

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

Nur um sicher zu gehen, habe ich es noch mehrmals wiederholt:

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

Und wie Sie sehen können, countist dreimal schneller als sum. Also würde ich vorschlagen, countwie in zu verwenden count_it.

Python-Version: 3.6.7
CPU-Kerne: 4
RAM-Größe: 16 GB
Betriebssystem: Ubuntu 18.04.1 LTS

Es ist sicherer, boolzuerst durchzulaufen . Dies ist einfach zu bewerkstelligen:

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

Dann fangen Sie alles, was Python als wahr oder falsch ansieht, im entsprechenden Bucket auf:

>>> 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]

Wenn Sie es vorziehen, können Sie ein Verständnis verwenden:

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

ich bevorzuge len([b for b in boollist if b is True]) (oder das Äquivalent zum Generatorausdruck), da es ziemlich selbsterklärend ist. Weniger "magisch" als die Antwort von Ignacio Vazquez-Abrams.

Alternativ können Sie dies tun, wobei weiterhin davon ausgegangen wird, dass bool in int konvertierbar ist, jedoch keine Annahmen über den Wert von True getroffen werden: ntrue = sum(boollist) / int(True)