python lowest cost of checking various equalities at once

Question

I start with a list full of False elements.
Then those elements are switched to True independently over the course of iterations.
I need to know when the list is fully True.

Let's say I have 3 elements, they start as

[False, False, False]

then I check them over the iterations like:

elements == [True, True, True]

The list of elements is fixed and should not grow (or shrink). You can think of these elements as switches, the input determines how many there are and they start all switched off. The only thing that can happen over time is that individual switches are turned on (True) by events happening in the iteration.

How does python do the checking and what is the cost?
What is the best way in terms of cost to check that?
Is there a way with bit operations or anything that checks all the elements at once?

Answer 1

Use all,

>>> l = [True, True, True]
>>> all(l)
True

Notice that if the iterable is empty, it will return True as well.

>>> all([])
True

Answer 2

You could create your own flag class, one which implements the idea of @StefanPochmann and keeps track of how many flags have been set.

Proof of concept:

class flags:
    def __init__(self,n):
        self.__flags = [False]*n
        self.__ntrue = 0

    def flags(self):
        return self.__flags[:] #so read only

    def __len__(self):
        return len(self.__flags)

    def check(self,i):
        return self.__flags[i]

    def on(self,i):
        if not self.check(i):
            self.__ntrue +=1
            self.__flags[i] = True

    def off(self,i):
        if self.check(i):
            self.__ntrue -=1
            self.__flags[i] = False

    def toggle(self,i):
        if self.check(i):
            self.off(i)
        else:
            self.on(i)

    def ntrue(self):
        return self.__ntrue

Tested like:

import random

i = 0
f = flags(5)
while f.ntrue() != len(f):
    i +=1
    f.toggle(random.randint(0,4))

print(i,f.flags())

Typical output:

19 [True, True, True, True, True]