Cómo convertir un binario (string) en un valor flotante?

Esta división ha sido aprobado por expertos así aseguramos la exactitud de nuestra esta división.

Solución:

En uno de sus comentarios indicó que el número binario representa un flotante en formato IEEE 754 binary64 de 8 bytes de longitud. Sin embargo, eso es incompatible con la -0b1110 valor que mostró como ejemplo, así que lo ignoré y usé el mío, que tiene el formato adecuado como datos de entrada de ejemplo para probar la respuesta que se muestra a continuación.

Esencialmente lo que se hace es primero el binario string se convierte en un valor entero, luego en un string de bytes sin formato que se pasa a struct.unpack() para la conversión final a un valor de coma flotante. los bin_to_float() La función que se muestra a continuación impulsa el proceso. Aunque no se ilustra, la entrada binaria string Los argumentos pueden ir precedidos de '0b'.

from codecs import decode
import struct


def bin_to_float(b):
    """ Convert binary string to a float. """
    bf = int_to_bytes(int(b, 2), 8)  # 8 bytes needed for IEEE 754 binary64.
    return struct.unpack('>d', bf)[0]


def int_to_bytes(n, length):  # Helper function
    """ Int/long to byte string.

        Python 3.2+ has a built-in int.to_bytes() method that could be used
        instead, but the following works in earlier versions including 2.x.
    """
    return decode('%%0%dx' % (length << 1) % n, 'hex')[-length:]


def float_to_bin(value):  # For testing.
    """ Convert float to 64-bit binary string. """
    [d] = struct.unpack(">Q", struct.pack(">d", value))
    return ':064b'.format(d)


if __name__ == '__main__':

    for f in 0.0, 1.0, -14.0, 12.546, 3.141593:
        print('Test value: %f' % f)
        binary = float_to_bin(f)
        print(' float_to_bin: %r' % binary)
        floating_point = bin_to_float(binary)  # Round trip.
        print(' bin_to_float: %fn' % floating_point)

Producción:

Test value: 0.000000
 float_to_bin: '0000000000000000000000000000000000000000000000000000000000000000'
 bin_to_float: 0.000000

Test value: 1.000000
 float_to_bin: '0011111111110000000000000000000000000000000000000000000000000000'
 bin_to_float: 1.000000

Test value: -14.000000
 float_to_bin: '1100000000101100000000000000000000000000000000000000000000000000'
 bin_to_float: -14.000000

Test value: 12.546000
 float_to_bin: '0100000000101001000101111000110101001111110111110011101101100100'
 bin_to_float: 12.546000

Test value: 3.141593
 float_to_bin: '0100000000001001001000011111101110000010110000101011110101111111'
 bin_to_float: 3.141593

Otra opción es hacer

from ast import literal_eval

float_str = "-0b101010101"
result = float(literal_eval(float_str))

A diferencia del “eval” incorporado, es seguro ejecutar literal_eval incluso con las entradas del usuario, ya que solo puede analizar literales de Python y no ejecutará expresiones, lo que significa que tampoco llamará a funciones.

Esto funciona para mí. Probado con Python3.4:

def float_to_bin(num):
    return bin(struct.unpack('!I', struct.pack('!f', num))[0])[2:].zfill(32)

def bin_to_float(binary):
    return struct.unpack('!f',struct.pack('!I', int(binary, 2)))[0]

float_to_bin(bin_to_float(float_to_bin(123.123))) == float_to_bin(123.123)
>>> True

---

---

Utiliza Nuestro Buscador