Convert bytes to int?

Question

I'm currently working on an encryption/decryption program and I need to be able to convert bytes to an integer. I know that:

bytes([3]) = b'\x03'

Yet I cannot find out how to do the inverse. What am I doing terribly wrong?

Beutler

There is also the struct module if you want to convert multiple variables at once. – Kike

Possible duplicate of Reading integers from binary file in Python, How to convert a string of bytes into an int in Python, etc. – Ballenger

inverse: b'\x03'[0] – Ectoenzyme

If you have a bytes object var = b'abc', then var[0] would return 97 and var[1] 98, and so on. – Resurrectionism

Answer 1

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

Carolinecarolingian

Thanks. Is there a difference between int.from_bytes and ord(b'\x03') for single bytes/chars? – Sidonie

The only difference I can think of is that int.from_bytes can interpret the byte as a signed integer if you tell it to - int.from_bytes(b'\xe4', "big", signed=True) returns -28, while ord() or int.from_bytes in unsigned mode returns 228. – Carolinecarolingian

use sys.byteorder to pass the byte order while calling. – Oxpecker

@KrishnaOza - that depends. If you're converting bytes that were encoded on a remote system, say because you're receiving them over a network connection, there's no guarantee that the remote system's native byte order matches yours. This has been a significant historical problem. – Carolinecarolingian

Answer 2

Lists of bytes are subscriptable (at least in Python 3.6). This way you can retrieve the decimal value of each byte individually.

>>> intlist = [64, 4, 26, 163, 255]
>>> bytelist = bytes(intlist)       # b'@\x04\x1a\xa3\xff'

>>> for b in bytelist:
...    print(b)                     # 64  4  26  163  255

>>> [b for b in bytelist]           # [64, 4, 26, 163, 255]

>>> bytelist[2]                     # 26 

Restriction

Answer 3

list() can be used to convert bytes to int (works in Python 3.7):

list(b'\x03\x04\x05')
[3, 4, 5]

Foggia

does not work in python 2.7 – Tannic

This answer is perfectly valid, because it does work in Python 3.7 – Foggia

In addition, tuple() also works in case you want an immutable sequence. – Tyree

Answer 4

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

doesn't work with me I used function from this website, it works well

https://coderwall.com/p/x6xtxq/convert-bytes-to-int-or-int-to-bytes-in-python

def bytes_to_int(bytes):
    result = 0
    for b in bytes:
        result = result * 256 + int(b)
    return result

def int_to_bytes(value, length):
    result = []
    for i in range(0, length):
        result.append(value >> (i * 8) & 0xff)
    result.reverse()
    return result

Unplaced

This should be equivalent to doing int.from_bytes(bytes, 'big') – Pithy

Answer 5

In case of working with buffered data I found this useful:

int.from_bytes([buf[0],buf[1],buf[2],buf[3]], "big")

Assuming that all elements in buf are 8-bit long.

Civic

Answer 6

convert bytes to bit string

format(int.from_bytes(open('file','rb').read()),'b')

Preshrunk

Answer 7

An old question that I stumbled upon while looking for an existing solution. Rolled my own and thought I'd share because it allows you to create a 32-bit integer from a list of bytes, specifying an offset.

def bytes_to_int(bList, offset):
    r = 0
    for i in range(4):
        d = 32 - ((i + 1) * 8)
        r += bList[offset + i] << d
    return r

Amon

Answer 8

#convert bytes to int 
    def bytes_to_int(value):
        return int.from_bytes(bytearray(value), 'little')

    bytes_to_int(b'\xa231')

Bragi