Convert a list of ints to a float

Question

I am trying to convert a number stored as a list of ints to a float type. I got the number via a serial console and want to reassemble it back together into a float. The way I would do it in C is something like this:

bit_data = ((int16_t)byte_array[0] << 8) | byte_array[1];
result = (float)bit_data;

What I tried to use in python is a much more simple conversion:

result = int_list[0]*256.0 + int_list[1]

However, this does not preserve the sign of the result, as the C code does. What is the right way to do this in python?

UPDATE: Python version is 2.7.3. My byte array has a length of 2. in the python code byte_array is list of ints. I've renamed it to avoid misunderstanding. I can not just use the float() function because it will not preserve the sign of the number.

Answer 1

I'm a bit confused by what data you have, and how it is represented in Python. As I understand it, you have received two unsigned bytes over a serial connection, which are now represented by a list of two python ints. This data represents a big endian 16-bit signed integer, which you want to extract and turn into a float. eg. [0xFF, 0xFE] -> -2 -> -2.0

import array, struct

two_unsigned_bytes = [255, 254] # represented by ints
byte_array = array.array("B", two_unsigned_bytes) 
# change above to "b" if the ints represent signed bytes ie. in range -128 to 127
signed_16_bit_int, = struct.unpack(">h", byte_array)
float_result = float(signed_16_bit_int)

Answer 2

I am not sure I really understand what you are doing, but I think you got 4 bytes from a stream and know them to represent a float32 value. The way you handling this suggests big-endian byte-order.

Python has the struct package (https://docs.python.org/2/library/struct.html) to handle bytestreams.

import struct

stream = struct.pack(">f", 2/3.)
len(stream) # 4

reconstructed_float = struct.unpack(">f", stream)

Answer 3

I think what you want is the struct module.

Here's a round trip snippet:

import struct
sampleValue = 42.13
somebytes = struct.pack('=f', sampleValue)
print(somebytes)
result = struct.unpack('=f', somebytes)
print(result)

result may be surprising to you. unpack returns a tuple. So to get to the value you can do

result[0]

or modify the result setting line to be

result = struct.unpack('=f', some bytes)[0] 

I personally hate that, so use the following instead

result , = struct.unpack('=f', some bytes) # tuple unpacking on assignment

The second thing you'll notice is that the value has extra digits of noise. That's because python's native floating point representation is double.

(This is python3 btw, adjust for using old versions of python as appropriate)

Answer 4

Okay, so I think int_list isn't really just a list of ints. The ints are constrained to 0-255 and represent bytes that can be built into a signed integer. You then want to turn that into a float. The trick is to set the sign of the first byte properly and then procede much like you did.

float((-(byte_array[0]-127) if byte_array[0]>127 else byte_array[0])*256 + byte_array[1])