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)
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)
len(bin(number)) - 2. bin(number) gives you 0b1010101, so you get the string's length and take 2 out of it.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.
"true" and "false" - to be clear, in general code, use the actual bool values True and False.
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.
Why bother with strings? This code is for 8 bits, but changing it should be obvious:
num = 19
bits = [False for i in range(8)]
for i in range(8):
bits[7-i] = True if num & 1 else False
num = num >> 1
print(bits)
This list comprehension will give you the data you need. Do you also want it formatted under table?
>>> [(i, b=='1', b) for i, b in enumerate('00010011')]
[(0, False, '0'), (1, False, '0'), (2, False, '0'), (3, True, '1'),
(4, False, '0'), (5, False, '0'), (6, True, '1'), (7, True, '1')]
num=19
for val in [bool(num & (1<<n)) for n in range(8)]:
print(val)
# do stuff
0and1characters)?[ bool(int(x)) for x in "00010011" ]would yield[False, False, False, True, False, False, True, True]. Is this what you aim for?bin()will never give you leading0s. And it'll be prefixed with0b.