You can use Python's struct module to convert the byte string to integers. It takes care of endianness and sign extension for you. I guess you are trying to interpret this 16-byte string as 8 2-byte signed integers, in big-endian byte order. The format string for this is '>8h. The > character tells Python to interpret the string as big endian, 8 means 8 of the following data type, and h means signed short integers.

import struct
nums = struct.unpack('>8h', bin_bytes)

Now nums is a tuple of integers that you can process further.

I'm not quite sure if your data is little or big endian. If it is little-endian, you can use < to indicate that in the struct.unpack format string.

However this does not work as the for j in bytes() converts a bytes element directly into an int j.

As you've noticed, the bytes is already an iterable over integer values. If we have a lot of data, it would be more memory efficient to keep the bytes as is, and convert values on demand. We can simply do the math to convert the unsigned interpretation of a byte to the corresponding signed representation:

def signed_byte(b):
    return b - 256 if b >= 128 else b

And wrap the indexing process:

def get_signed(data, index):
    return signed_byte(data[index])

If we want or need to do all the conversion ahead of time, that feeds directly into the list comprehension:

ints = [signed_byte(b) for b in b'\xff\xff\x01']

On the other hand, we can reframe the question: to get a bytes object from the original data as a subsequence (like how it worked in 2.x), we can use a 1-element slice instead; or we can wrap the int value into a new bytes. The former will be tricky to adapt to the original code, but the latter is trivial:

ints = [int.from_bytes(bytes([b]), byteorder='little', signed=True) for b in b'\xff\xff\x01']

Frame Challenge: Bytes should not be integers.

Bytes are bytes, a fixed-size sequence of bits, typically 8 on modern computers.

Should an array of bits be signed or unsigned? Neither, the question is nonsensical: an array cannot be signed or unsigned in the first place.

There's a long-standing tradition in programming languages to conflate integers and array of bits, which can be seen in that bit-wise operations are typically defined on integers. I argue that this "blending" of the two roles is a mistake: a violation of the Single Responsibility Principle.

Yes, it's all registers at the end... should a pointer be signed or unsigned? Surely nowadays the question seems nonsensical, even though in B pointers and integers were the same type, and in CPU they are manipulated through the same registers.

Just like pointers are different from integers, I hereby argue that array of bits should be different from integers, and bit-wise functions are only sensible on array of bits.

The conversion between integer and array of bits (of the same number of bits) should exist -- just like that between floating point or decimal an array of bits -- and it should ideally boil down to a no-op, but from a type system, the two should be separate.

error messgae is clear , if your vaue includes signs you need to pass signed =True when you convert it to bytes:

an_int = -5
a_bytes_big = an_int.to_bytes(2, 'big', signed = True)
print(a_bytes_big)

If you want to use signed 8bit integers for GeoTIFFs use datatype Byte together with creation options PIXELTYPE=SIGNEDBYTE

https://gdal.org/drivers/raster/gtiff.html

gdal_translate -ot Byte -a_nodata -1 -co PIXELTYPE=SIGNEDBYTE input.tif output.tif

Subtract 256 if over 127:

unsigned = ord(character)
signed = unsigned - 256 if unsigned > 127 else unsigned

Alternatively, repack the byte with the struct module:

from struct import pack, unpack
signed = unpack('B', pack('b', unsigned))[0]

or directly from the character:

signed = unpack('B', character)[0]

-2 is not correct for the values you have specified, and byte order matters. struct uses > for big-endian (most-significant byte first) and < for little-endian (least-significant byte first):

>>> import struct
>>> struct.pack('>h',-2)
'\xff\xfe'
>>> struct.pack('<h',-2)
'\xfe\xff'
>>> p1=chr(254) # 0xFE
>>> p0=chr(255) # 0xFF
>>> struct.unpack('<h',p1+p0)[0]
-2
>>> struct.unpack('>h',p0+p1)[0]
-2

Use the struct module.

import struct
value = struct.unpack('B', data[0:1])[0]

We have to specify a range of 1 (0:1), because Python 3 converts automatically to an integer otherwise.

Note that unpack always returns a tuple, even if you're only unpacking one item.

Also, have a look at this SO question.

Use a different operation for bit flipping.

E.g.:¹

array[i] = 255 - array[i]

or also:

array[i] = 255 ^ array[i]

will flip all (i.e.: 8) bits.

¹ the math behind this can be worked out from two's complement wikipedia page.

Assuming you're on at least 3.2, there's a built in for this:

int.from_bytes( bytes, byteorder, *, signed=False )

...

The argument bytes must either be a bytes-like object or an iterable producing bytes.

The byteorder argument determines the byte order used to represent the integer. If byteorder is "big", the most significant byte is at the beginning of the byte array. If byteorder is "little", the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value.

The signed argument indicates whether two’s complement is used to represent the integer.

## Examples:
int.from_bytes(b'\x00\x01', "big")                         # 1
int.from_bytes(b'\x00\x01', "little")                      # 256

int.from_bytes(b'\x00\x10', byteorder='little')            # 4096
int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)  #-1024

If you're using Python > 3.2 you could use int.from_bytes:

int.from_bytes(b, byteorder='little', signed=True)