This is kind of an old thread, but in Python 3.2+ now you can simply say:

number = 100
number.to_bytes(4, byteorder = 'big')

or byteorder = 'little' as per your needs. Documentation here.

In Python 3.2 and later, use

>>> int.from_bytes(b'y\xcc\xa6\xbb', byteorder='big')
2043455163

or

>>> int.from_bytes(b'y\xcc\xa6\xbb', byteorder='little')
3148270713

according to the endianness of your byte-string.

This also works for bytestring-integers of arbitrary length, and for two's-complement signed integers by specifying signed=True. See the docs for from_bytes.

You could convert it to a bytearray and pass that to struct.unpack().

import struct

data = [123, 45, 67, 89]

# Show hex values of data.
print(list('%02x' % b for b in data))  # -> ['7b', '2d', '43', '59']

# Convert to 4 byte unsigned integer data interpreting data as being in 
# little-endian byte order.
value = struct.unpack("<I", bytearray(data))[0]
print(hex(value))  # -> 0x59432d7b

In binary, 3 and 132 are 00000011 and 10000100 respectively. 900 in binary is 1110000100. By concatenating the binary representations of 3 and 132, you get 900.

00000011
+       10000100
================
0000001110000100

You can use struct.unpack to convert bytes into other types.

>>> import struct
>>> x = b'\x00\x00\x03\x84\x00\x00\x04\xb0'
>>> struct.unpack(">II", x)
(900, 1200)

The ">II" format string indicates that the eight-byte bytes object should be interpreted as two four-byte integers with little-endian byte ordering.

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

To decode binary data, use struct.unpack().

>>> import struct
>>> byte_range = bytearray(b'\x85W\xe2\xa2I')
>>> date_header, timestamp = struct.unpack('>BL', byte_range)
>>> date_header
133
>>> timestamp
1474470473