Let's say I have a series of integers:
var = [1, 5, 4, 17, 231, 89]
If I wanted to transform these into bytes, I could use the following code:
[(i).to_bytes(1, byteorder='big') for i in var]Since each number in var is under 256, it can be represented using one byte per integer. However, if I had another list like this:
var = [1, 2, 15, 12]
This time, each integer can fit into half a byte, or more precisely, two integers can be packed into a single byte.
How would I specify that I want to combine two integers into a byte whenever feasible, both during conversion and back?
An example implementation could look like this:
var1 = [1, 5, 4, 17, 231, 89]
var2 = [1, 2, 15, 12]
def foo(var):
if max(var) < 2**4:
num_bytes = 0.5
elif max(var) < 2**8:
num_bytes = 1
elif max(var) < 2**16:
num_bytes = 2
if num_bytes >= 1:
return [(i).to_bytes(num_bytes, byteorder='big') for i in var], num_bytes
elif num_bytes = 0.5:
# convert var to list of nybbles
# merge two nybbles into a byte
# generate list of bytes (half the length of var)
# return the result along with num_bytes
def unfoo(var, num_bytes):
if num_bytes >= 1:
print([int.from_bytes(i, 'big') for i in var])
elif num_bytes = 0.5:
# reprint original integer list here
I aim to change a list of integers into a list of bytes, arranging two nybbles within a byte when feasible, and then convert them back.
The desired outcome should be as follows:
a, b = foo(var1)
unfoo(a, b) # prints [1, 5, 4, 17, 231, 89]
a, b = foo(var2)
unfoo(a, b) # prints [1, 2, 15, 12]
I am not seeking the smallest representation possible for individual numbers. Take note of the max(list): if all values can be 8-bit, convert to 8-bit; if they are all able to fit in 16-bits, adjust accordingly; if each value fits in a nybble, pack two nybbles into a list of bytes.
In essence, how do you merge two single-nybble integers into a single byte? If I know that bytes must be divided into two parts, what approach should be taken? It is safe to assume that the initial list will be even.