list has a count method:

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

This is actually more efficient than sum, as well as being more explicit about the intent, so there's no reason to use 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)

Basically there are two functions that deal with an iterable and return True or False depending on which boolean values elements of the sequence evaluate to.

1. all(iterable) returns True if all elements of the iterable are considered as true values (like reduce(operator.and_, iterable)).

2. any(iterable) returns True if at least one element of the iterable is a true value (again, using functional stuff, reduce(operator.or_, iterable)).

Using the all function, you can map operator.not_ over your list or just build a new sequence with negated values and check that all the elements of the new sequence are true:

>>> all(not element for element in data)

With the any function, you can check that at least one element is true and then negate the result since you need to return False if there's a true element:

>>> not any(data)

According to De Morgan's law, these two variants will return the same result, but I would prefer the last one (which uses any) because it is shorter, more readable (and can be intuitively understood as "there isn't a true value in data") and more efficient (since you don't build any extra sequences).

What's happening here is a little confusing, since [1,2,3][True] has two sets of []s that are being interpreted in different ways.

What's going on is a little more clear if we split the code over a few lines.

The first set of []s construct a list object. Let's assign that object the name a:

>>> [1,2,3]
[1, 2, 3]
>>> a = [1,2,3]
>>>

The second set of [] specify an index inside that list. You'd usually see code like this:

>>> a[0]
1
>>> a[1]
2
>>>

But it's just as valid to use the list object directly, without ever giving it a name:

>>> [1,2,3][0]
1
>>> [1,2,3][1]
2

Lastly, the fact that True and False are useable as indexes is because they're treated as integers. From the data model docs:

There are three types of integers:

Plain integers....

Long integers.....

Booleans

These represent the truth values False and True. The two objects representing the values False and True are the only Boolean objects. The Boolean type is a subtype of plain integers, and Boolean values behave like the values 0 and 1, respectively, in almost all contexts, the exception being that when converted to a string, the strings "False" or "True" are returned, respectively.

Thus, [1,2,3][True] is equivalent to [1,2,3][1]

Basically, you want your list of booleans to be sorted.

Specifically, since True > False, you want your list to be sorted in decreasing order:

def check_true_then_false(booleans):
    return booleans == sorted(booleans, reverse=True)

Done!

>>> test_cases = [[True],
...               [False],
...               [True, False],
...               [True, False, False],
...               [True, True, True, False],
...               [False, True],
...               [True, False, True]]
>>> 
>>> print([check_true_then_false(test_case) for test_case in test_cases])
[True, True, True, True, True, False, False]

Like so:

filtered_list = [i for (i, v) in zip(list_a, filter) if v]

Using zip is the pythonic way to iterate over multiple sequences in parallel, without needing any indexing. This assumes both sequences have the same length (zip stops after the shortest runs out). Using itertools for such a simple case is a bit overkill ...

One thing you do in your example you should really stop doing is comparing things to True, this is usually not necessary. Instead of if filter[idx]==True: ..., you can simply write if filter[idx]: ....

If you mean is actually True and not evaluates to True, you can just count them?

>>> L1 = [True]*5
>>> L1
[True, True, True, True, True]
>>> L2 = [True]*5 + [False]*2
>>> L2
[True, True, True, True, True, False, False]
>>> L1.count(False)
0
>>> L2.count(False)
2
>>> 

checking for only a single False:

>>> def there_can_be_only_one(L):
...     return L.count(False) == 1
... 
>>> there_can_be_only_one(L1)
False
>>> there_can_be_only_one(L2)
False
>>> L3 = [ True, True, False ]
>>> there_can_be_only_one(L3)
True
>>> 

edit: This actually answer your question better:

>>> def there_must_be_only_one(L):
...     return L.count(True) == len(L)-1
... 
>>> there_must_be_only_one(L3)
True
>>> there_must_be_only_one(L2)
False
>>> there_must_be_only_one(L1)
False

The result an expression (whether True or False), is determined by how it is expressed as a boolean expression. Python differs from strongly typed languages like Java in that any expression (even a variable reference) can be evaluated to a boolean. Refer to Truth Value Testing.

By default, an object is considered True unless its class defines either a bool() method that returns False or a len() method that returns zero, when called with the object.

Here are 3 statements to consider:

1. li = [""]
2. li == True
3. if li: print("li is true")

• Line 1, assign a non-empty list to variable li
• Line 2, list instance is not a boolean value so expression is evaluated as False, likewise li == False also evaluates to False.
• Line 3, if li: ... evaluates same as if bool(li): print... which evaluates to True and prints "li is true".

If evaluate the expression bool(li), the value is True since the list variable is non-empty and len() function returns 1. An empty List len() returns 0 so will return False.