I know python probably isn't the best tool for this, but let's say I have a value that I would like to display as an unsigned char with values between -128 and 127. For example:
# ok for positive number
>>> f'0b{1:>08b}'
'0b00000001'
# how to do it for negative number?
>>> f'0b{-1:>08b}' # should be 0b11111111
'0b000000-1'
# how to do it for 2's complement?
>>> f'0b{~1:>08b}' # should be 0b11111110
'0b00000-10'
How could I do this display in python?
Use modulo 256.
# positive number is the same
>>> f'0b{1 % 0x100:>08b}'
'0b00000001'
# correct bit pattern, were you to notate -1 in a signed int8
# same as notating 255 in unsigned int8, which is what -1 % 255 is
>>> f'0b{-1 % 0x100:>08b}'
'0b11111111'
# flipped bits from 1, truncated to only the least significant 8 digits
>>> f'0b{~1 % 0x100:>08b}'
'0b11111110'
Essentially this is just 'convert your signed char into an unsigned char, and print the bit pattern' - the benefit of using the modulo operator is you always get a positive number, and if your modulo is a power of two, the bit pattern for every bit less than that modulus is left exactly the same.
& 0xff. I find it clearer, especially since this code might be read by people less familiar with how Python's % behavior deviates from C. (% 256 wouldn't work in C.)& 0xFF equivalent to % (0xFF + 1) ? Does that work across most languages or it's a python thing?
& 0xFF (bitwise AND) would work the same in this circumstance, yes, and is almost certainly the better choice. I'm not going to edit my answer, as it would change basically the whole thing (I didn't think of bitwise AND when writing it), but hopefully anyone interested can read the comments below). This is kind of a moot point if we're considering static-typed languages like C (in which case you can just do *((unsigned char*) &char) without direct bit manipulation), but it should work in dynamically-typed languages like python and javascript.You could try manually setting the bits like this knowing that 2^n - 1 sets the first n bits:
>>> negative =lambda value, bits: bin(2**bits-1-value+1)
>>> complement =lambda value, bits: bin(2**bits-1-value)
# to verify (note, python doesn't 'know' its 1 byte so will
# equal 256 unless we do the 1-byte mask with &0xFF
>>> (1+int(complement(1,8),2))&0xFF
0
pack-- basically I'm just trying to use the python interpreter to quickly do math of values-in-c (if that's possible)