Iterate between bits in a binary number

Question

How can I iterate and evaluate the value of each bit given a specific binary number in python 3?

For example:

00010011 
--------------------
bit position | value
--------------------
[0]            false (0)
[1]            false (0)
[2]            false (0)
[3]            true  (1)
[4]            false (0)
[5]            false (0)
[6]            true  (1)
[7]            true  (1)

Answer 1

It's better to use bitwise operators when working with bits:

number = 19

num_bits = 8
bits = [(number >> bit) & 1 for bit in range(num_bits - 1, -1, -1)]

This gives you a list of 8 numbers: [0, 0, 0, 1, 0, 0, 1, 1]. Iterate over it and print whatever needed:

for position, bit in enumerate(bits):
    print '%d  %5r (%d)' % (position, bool(bit), bit)

Answer 2

Python strings are sequences, so you can just loop over them like you can with lists. Add enumerate() and you have yourself an index as well:

for i, digit in enumerate(binary_number_string):
    print '[{}] {:>10} ({})'.format(i, digit == '1', digit)

Demo:

>>> binary_number_string = format(19, '08b')
>>> binary_number_string
'00010011'
>>> for i, digit in enumerate(binary_number_string):
...     print '[{}] {:>10} ({})'.format(i, digit == '1', digit)
... 
[0]      False (0)
[1]      False (0)
[2]      False (0)
[3]       True (1)
[4]      False (0)
[5]      False (0)
[6]       True (1)
[7]       True (1)

I used format() instead of bin() here because you then don't have to deal with the 0b at the start and you can more easily include leading 0.

Answer 3

Surprisingly, converting the integer to a string is quite a bit faster than using binary operations. Benchmarking on a Core i9 running MacOS 10.15 with Python 3.7.6:

In [6]: number = 1 << 30

In [7]: num_bits = 32

In [8]: %timeit bits = [c == '1' for c in format(number, f'0{num_bits}b')]
1.84 µs ± 8.51 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [9]: %timeit bits = [(number >> bit) & 1 for bit in range(num_bits - 1, -1, -1)]
3.13 µs ± 69.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

The format() approach runs in 60% of the time of the bitwise operators approach! (Nor is it changed much if you add an if-else to get a list of integers instead of booleans.)

I assume this is because Python integers are stored behind the scenes in a way that doesn't allow for efficient bitwise operations.