Python преобразует число с плавающей точкой в ​​32 бита ieee [duplicate]

После просмотра многих похожих вопросов я написал что-то, что, надеюсь, сделает то, что я хотел.

f = 1.00
negative = False
if f < 0:
    f = f*-1
    negative = True

s = struct.pack('>f', f)
p = struct.unpack('>l', s)[0]
hex_data =  hex(p)

scale = 16
num_of_bits = 32
binrep = bin(int(hex_data, scale))[2:].zfill(num_of_bits)
if negative:
    binrep = '1' + binrep[1:]

binrep - результат. Каждая часть будет объяснена.

f = 1.00
negative = False
if f < 0:
    f = f*-1
    negative = True

Преобразует число в положительное, если отрицательное, и устанавливает переменную отрицательную в значение false. Причина этого заключается в том, что разница между положительными и отрицательными двоичными представлениями находится только в первом бите, и это был более простой способ, чем выяснить, что происходит не так, когда весь процесс обрабатывается с отрицательными числами.

s = struct.pack('>f', f)                          #'?\x80\x00\x00'
p = struct.unpack('>l', s)[0]                     #1065353216
hex_data =  hex(p)                                #'0x3f800000'

s является шестнадцатеричным представлением двоичного файла f. это, однако, не в симпатичной форме, в которой я нуждаюсь. То, где p входит. Это int-представление шестнадцатеричных s. А затем другое преобразование, чтобы получить симпатичный гекс.

scale = 16
num_of_bits = 32
binrep = bin(int(hex_data, scale))[2:].zfill(num_of_bits)
if negative:
    binrep = '1' + binrep[1:]

scale является базой 16 для шестнадцатеричного. num_of_bits равно 32, так как float 32 бита, он используется позже, чтобы заполнить дополнительные места 0, чтобы добраться до 32. Получил код для binrep из этого вопроса . Если число было отрицательным, просто измените первый бит.

Я знаю, что это уродливо, но я не нашел приятного пути, и мне это было нужно быстро. Комментарии приветствуются.

Некоторые из этих ответов не работали так, как написано с Python 3, или не дали правильного представления для отрицательных чисел с плавающей запятой. Я нашел следующее для работы для меня (хотя это дает 64-битное представление, которое мне нужно)

def float_to_binary_string(f):
    def int_to_8bit_binary_string(n):
        stg=bin(n).replace('0b','')
        fillstg = '0'*(8-len(stg))
        return fillstg+stg
    return ''.join( int_to_8bit_binary_string(int(b)) for b in struct.pack('>d',f) )

Для полноты вы можете добиться этого с помощью numpy, используя:

f = 1.00
int32bits = np.asarray(f, dtype=np.float32).view(np.int32).item()  # item() optional

Затем вы можете распечатать это с помощью дополнения, используя спецификатор формата b

print('{:032b}'.format(int32bits))

Это немного больше, чем было задано, но это было то, что мне нужно, когда я нашел эту запись. Этот код предоставит мантиссе, базу и знак 32-битного поплавка IEEE 754.

import ctypes
def binRep(num):
    binNum = bin(ctypes.c_uint.from_buffer(ctypes.c_float(num)).value)[2:]
    print("bits: " + binNum.rjust(32,"0"))
    mantissa = "1" + binNum[-23:]
    print("sig (bin): " + mantissa.rjust(24))
    mantInt = int(mantissa,2)/2**23
    print("sig (float): " + str(mantInt))
    base = int(binNum[-31:-23],2)-127
    print("base:" + str(base))
    sign = 1-2*("1"==binNum[-32:-31].rjust(1,"0"))
    print("sign:" + str(sign))
    print("recreate:" + str(sign*mantInt*(2**base)))

binRep(-0.75)

:

bits: 10111111010000000000000000000000
sig (bin): 110000000000000000000000
sig (float): 1.5
base:-1
sign:-1
recreate:-0.75

Эта проблема более корректно обрабатывается, разбивая ее на две части.

Первым является преобразование float в int с эквивалентным битовым шаблоном:

def float32_bit_pattern(value):
    return sum(ord(b) << 8*i for i,b in enumerate(struct.pack('f', value)))

Next преобразуйте int в строку:

def int_to_binary(value, bits):
    return bin(value).replace('0b', '').rjust(bits, '0')

Теперь соедините их:

>>> int_to_binary(float32_bit_pattern(1.0), 32)
'00111111100000000000000000000000'

Вот уродливый ...

>>> import struct
>>> bin(struct.unpack('!i',struct.pack('!f',1.0))[0])
'0b111111100000000000000000000000'

В принципе, я просто использовал структурный модуль для преобразования float в int ...

Вот немного лучше, используя ctypes:

>>> import ctypes
>>> bin(ctypes.c_uint.from_buffer(ctypes.c_float(1.0)).value)
'0b111111100000000000000000000000'

В принципе, я создаю float и использую ту же ячейку памяти, но я помещаю ее как c_uint. Значение c_uint представляет собой целое число python, на которое вы можете использовать встроенную функцию bin.

Вы можете использовать .format для самого легкого представления бит на мой взгляд:

мой код будет выглядеть примерно так:

def fto32b(flt):
# is given a 32 bit float value and converts it to a binary string
if isinstance(flt,float):
    # THE FOLLOWING IS AN EXPANDED REPRESENTATION OF THE ONE LINE RETURN
            #   packed = struct.pack('!f',flt) <- get the hex representation in (!)Big Endian format of a (f) Float
            #   integers = []
            #   for c in packed:
            #       integers.append(ord(c))    <- change each entry into an int
            #   binaries = []
            #   for i in integers:
            #       binaries.append("{0:08b}".format(i)) <- get the 8bit binary representation of each int (00100101)
            #   binarystring = ''.join(binaries) <- join all the bytes together
            #   return binarystring
    return ''.join(["{0:08b}".format(i) for i in [ord(c) for c in struct.pack('!f',flt)]])
return None

Выход:

>>> a = 5.0
'01000000101000000000000000000000'
>>> b = 1.0
'00111111100000000000000000000000'

Нашел другое решение, используя модуль bitstring .

import bitstring
f1 = bitstring.BitArray(float=1.0, length=32)
print f1.read('bin')

Выход:

00111111100000000000000000000000