I need to have huge boolean array. All values should be initialized as "True":
arr = [True] * (10 ** 9)
But created as above it takes too much memory. So I decided to use bytearray for that:
arr = bytearray(10 ** 9) # initialized with zeroes
Is it possible to initialize bytearray with b'\x01' as effectively as it is initialized by b'\x00'?
I understand I could initialize bytearray with zeros and inverse my logic. But I'd prefer not to do that if possible.
timeit:
>>> from timeit import timeit
>>> def f1():
... return bytearray(10**9)
...
>>> def f2():
... return bytearray(b'\x01'*(10**9))
...
>>> timeit(f1, number=100)
14.117428014000325
>>> timeit(f2, number=100)
51.42543800899875
Easy, use sequence multiplication:
arr = bytearray(b'\x01') * 10 ** 9
Same approach works for initializing with zeroes (bytearray(b'\x00') * 10 ** 9), and it's generally preferred, since passing integers to the bytes constructor has been a source of confusion before (people sometimes think they can make a single element bytes with the value of the integer).
You want to initialize the single element bytearray first, then multiply, rather than multiplying the bytes and passing it to the bytearray constructor, so you avoid doubling your peak memory requirements (and requiring reading from one huge array and writing to another, on top of the simple memset-like operation on a single array that any solution requires).
In my local tests, bytearray(b'\x01') * 10 ** 9 runs exactly as fast as bytearray(10 ** 9); both took ~164 ms per loop, vs. 434 ms for multiplying the bytes object, then passing it to bytearray constructor.