Bitwise Slicing

[Peter_Truman]

Hi - New to Python so please forgive any mistakes

I want to know if there is a more elegant way of slicing a byte?

I have an 8 bit result from reading a Port Expander (4 MSB's are where my inputs are connected)
In_1, In_2, In_3, In_4 will be used in the main program

def input_status(result): #gets a byte value and returns input status result = result | 15 # mask out the bottom 4 bits (not really needed) result = result >>4 #only interested in the 4 MSBs In_1 = result & 1 #check bit 0 result = result >>1 #shift 1 place right In_2 = result & 1 #check bit 1 result = result >>1 #shift 1 place right In_3 = result & 1 #check bit 2 I_result = result >>1 #shift 1 place right In_4 = I_result & 1 #check bit 3 return (In_1, In_2, In_3, In_4)

This works fine, but seems like a very cumbersome way of doing things?

I was looking for some sort of alias command where I could specify that In_1 = result.4 or something similar but I've not been able to find one.

Thanks for the help - still at the bottom of the learning curve

[micseydel]

I spent ~20 minutes trying to come up with something more elegant, and I believe I've failed:

def f(result): return tuple(int(result & 2**x > 1) for x in range(4, 8)) def f2(result): result = result >> 4 return tuple(result >> x & 1 for x in range(4)) def f3(result): return tuple(result >> x & 1 for x in range(4, 8)) def f4(result): return tuple(int(digit) for digit in f"{(result >> 4) & 15:04b}"[::-1])

Solutions I gave up on but tried include using reduce() and recursion.

[bowlofred]

I think the bitwise operators are the way to go. But you *could* print out the binary representation string and then index into it.

result = 231 # high bits are "1110" bits = [1 if x == "1" else 0 for x in f"{result:08b}"[-8:]] # takes only 8 LSB in case result > 2**8 for i in range(4): print(bits[i])

Output:
1 1 1 0

[Peter_Truman]

Ok - thanks for that. Good learning for me - I'm still not fully conversant with the way Python handles data (I'm used to PIC programming - where I can break everything down to the bit level.

If I went with

bits = [1 if x == "1" else 0 for x in f"{result:08b}"[-8:]] # takes only 8 LSB in case result > 2**8

Would that not simply leave me with a string called 'bits' - so effectively just masking out the lower 4 bits of result?

I need to be able to access and act on individual bit values (input is On or Off)

Thanks again

[deanhystad]

def bits(value, size=32): bit_values = [] for bit in range(size): bit_values.insert(0, value & 1) value = value >> 1 return bit_values print(bits(42, 8)) def bitslice(value, start, end): retvalue = 0 for bit in range(start, end+1): retvalue += (value & 1 << bit) >> start return retvalue print(bitslice(42, 1, 5), bits(bitslice(42, 1, 5), 5)) def bit(value, index): return (value & 1 << index) >> index print([bit(42, i) for i in range(8)]) def setbit(value, bit): return value | 1 << bit def clrbit(value, bit): mask = 1 << bit if value & mask == 0: return value return value ^ mask print(setbit(5, 1), clrbit(7, 1))

[bowlofred]

If I went with

bits = [1 if x == "1" else 0 for x in f"{result:08b}"[-8:]] # takes only 8 LSB in case result > 2**8

Would that not simply leave me with a string called 'bits' - so effectively just masking out the lower 4 bits of result?

No, it's just compact. The first part (the f-string) converts the byte to the 8 LSB bits as a string object. f"{result:08b}"[-8:]

The next part goes through each character of the string one-by-one and converts it to a list of numbers, either 0 or 1. So the MSB is index 0 and the LSB is index 7, via a list comprehension. Expanding the loop, it would look like:

temp_list = [] for x in f"{result:08b}"[-8:]: if x == "1": temp_list.append(1) else: temp_list.append(0) bits = temp_list

So at the end, you've got the list [1, 1, 1, 0, 0, 1, 1, 1]

It looks like there's also a PyPi module called bitstring. It could be that it has some functions that would be useful.

[Peter_Truman]

Thanks to all - the bitstring module looks much more natural to my eyes. I'll give this all a whirl in the morning.

Cheers