Python Forum

Hello,
I have a function that take bits and cut them according to my needs

BITS_ORDER_CHANGE = {8: 0, 7: 1, 6: 2, 5: 3, 4: 4, 3: 5, 2: 6, 1: 7}

def GetBits(Byte, start, end):  # bits order 8765 4321 , str order 0123 4567
    Final_calculation = round((int(Byte, 16) * 1 + 0), 0)
    bits = "{0:b}".format(Final_calculation)
    Full_bits = bits.zfill(8)
    print('old start', start)
    start = BITS_ORDER_CHANGE[start]
    print('new start', start)
    print('old end', end)
    end = BITS_ORDER_CHANGE[end]
    print('new end', end)
    Wanted_bits = Full_bits[end:start]
    return Wanted_bits

my problem is that when I cut it I think is string mode , whie the bits are is in bits mode
so it's other way around

for example
if I take "CA"
in bits its - 1100 1010
I want to cut only bits 2-4
but I need to enter numbers 4-7

then I thought to use dictionary - but then it's went wrong
I need to change the order - (end - start) , and it also change the order of the bits
01 - change to 10

is there other way to do it? without overthinking what need to be cut?


Thanks,

Don't convert to a string. Use shift and bitwise and. The convention I am familiar with has bit order starting at 0, not 1.

import math

def bit_slicer(value, lsb, msb=None):
    """Slice bits[lsb:msb] from value.  Return as int"""
    if msb is None:
        msb = lsb
    if msb < lsb:
        raise ValueError("msb must be greater or equal to lsb")
    mask = (2 << (msb-lsb)) - 1
    return (value >> lsb) & mask

def bits(value, lsb=0, msb=None):
    """Return bits[lsb:msb] from value.  Return as list"""
    if msb is None:
        msb = int(math.log(value, 2))
    if msb < lsb:
        raise ValueError("msb must be greater or equal to lsb")
    return [1 if value & (1 << bit) else 0 for bit in range(lsb, msb+1)]

print(bit_slicer(0xCA, 2, 4))
print(bits(0xCA, 2, 4))
print(bits(0xCA))

Output:
2
[0, 1, 0]
[0, 1, 0, 1, 0, 0, 1, 1]

But if you want to stay with doing this the string way, just reverse the order of the bit string.

import math

def bits(value, lsb=0, msb=None):
    """Return bits[lsb:msb] from value.  Return as list"""
    if msb is None:
        msb = int(math.log(value, 2))
    if msb < lsb:
        raise ValueError("msb must be greater or equal to lsb")
    bits = f"{value:b}".zfill(msb)[::-1]  # Reverse the order
    return [int(bit) for bit in bits[lsb:msb+1]]

print(bits(0xCA))

Output:
[0, 1, 0, 1, 0, 0, 1, 1]

see: https://wiki.python.org/moin/BitwiseOperators
and: https://wiki.python.org/moin/BitManipulation
and: https://wiki.python.org/moin/BitArrays

The second link has many examples