Конвертировать гекс в плавающий

Как преобразовать следующую шестнадцатеричную строку в число с плавающей точкой (32-битная одинарная точность) в Python?

"41973333" -> 1.88999996185302734375E1

"41995C29" -> 1.91700000762939453125E1

"470FC614" -> 3.6806078125E4
Источник

7 ответов

Решение
>>> import struct
>>> struct.unpack('!f', '41973333'.decode('hex'))[0]
18.899999618530273
>>> struct.unpack('!f', '41995C29'.decode('hex'))[0]
19.170000076293945
>>> struct.unpack('!f', '470FC614'.decode('hex'))[0]
36806.078125

Обновление: см. Комментарий о том, как это сделать в Python 3.

Источник

Я рекомендую использовать модуль ctypes, который в основном позволяет работать с низкоуровневыми типами данных. В вашем случае вы могли бы сказать

from ctypes import *

def convert(s):
    i = int(s, 16)                   # convert from hex to a Python int
    cp = pointer(c_int(i))           # make this into a c integer
    fp = cast(cp, POINTER(c_float))  # cast the int pointer to a float pointer
    return fp.contents.value         # dereference the pointer, get the float

print convert("41973333")    # returns 1.88999996185302734375E1

print convert("41995C29")    # returns 1.91700000762939453125E1

print convert("470FC614")    # returns 3.6806078125E4

Я считаю, что ctypes Модуль имеет здесь смысл, потому что вы по сути спрашиваете, как выполнять низкоуровневое приведение битов. Ваш вопрос в основном, как мне сказать Python взять некоторые данные и интерпретировать эти данные, как если бы эти точно такие же биты были другого типа данных?

В C, если у вас есть int и вы хотите интерпретировать его биты как float, вы должны делать примерно то же самое, беря указатель, а затем приводя и разыскивая его:

int i = 0x41973333;
float f = *((float*)&i);

и это именно то, что код Python, использующий ctypes библиотека делает в моем примере.

Источник

Я предполагаю, что этот вопрос относится к этому, и вы работаете с 4 байтами, а не с 8 шестнадцатеричными цифрами.

"\x41\x91\x33\x33" 4-байтовая строка, хотя выглядит как 16

>>> len("\x41\x91\x33\x33")
4
>>> import struct  
>>> struct.unpack(">fff","\x41\x97\x33\x33\x41\x99\x5C\x29\x47\x0F\xC6\x14")
(18.899999618530273, 19.170000076293945, 36806.078125)

Если вам нужно иметь дело со строкой шестнадцатеричных чисел, а не с действительными байтами, вы можете использовать struct.pack чтобы преобразовать это, как это

>>> for hx in ["41973333","41995C29","470FC614"]:
...     print(struct.unpack(">f",struct.pack(">i",int(hx,16)))[0])
... 
18.8999996185
19.1700000763
36806.078125
Источник

Разделите шестнадцатеричные строки на 2-символьные куски (байты), сделайте каждый кусочек в правильный байт с форматированием int, struct.unpack, когда закончите. То есть:

import struct 

testcases = {
"41973333": 1.88999996185302734375E1,
"41995C29": 1.91700000762939453125E1,
"470FC614": 3.6806078125E4,
}

def hex2float(s):
    bins = ''.join(chr(int(s[x:x+2], 16)) for x in range(0, len(s), 2))
    return struct.unpack('>f', bins)[0]

for s in testcases:
  print hex2float(s), testcases[s]

испуская, по желанию:

18.8999996185 18.8999996185
19.1700000763 19.1700000763
36806.078125 36806.078125
Источник

При работе со строкой и без необходимости нарезать или индексировать значения.

      import struct
...
q = int('0x425c0000',16)
b8 = struct.pack('i', q)
dec, = struct.unpack('f', b8)
Источник

Гентельмены...

    class fl:
        def __init__(this, value=0, byte_size=4):

            this.value = value

            if this.value: # speedy check (before performing any calculations)
                Fe=((byte_size*8)-1)//(byte_size+1)+(byte_size>2)*byte_size//2+(byte_size==3)
                Fm,Fb,Fie=(((byte_size*8)-(1+Fe)), ~(~0<<Fe-1), (1<<Fe)-1)

                FS,FE,FM=((this.value>>((byte_size*8)-1))&1,(this.value>>Fm)&Fie,this.value&~(~0 << Fm))
                if FE == Fie: this.value=(float('NaN') if FM!=0 else (float('+inf') if FS else float('-inf')))
                else: this.value=((pow(-1,FS)*(2**(FE-Fb-Fm)*((1<<Fm)+FM))) if FE else pow(-1,FS)*(2**(1-Fb-Fm)*FM))

                del Fe; del Fm; del Fb; del Fie; del FS; del FE; del FM

            else: this.value = 0.0

    print fl( 0x41973333 ).value # >>> 18.899999618530273
    print fl( 0x41995C29 ).value # >>> 19.170000076293945
    print fl( 0x470FC614 ).value # >>> 36806.078125
    print fl( 0x00800000 ).value # >>> 1.1754943508222875e-38 (minimum float value)
    print fl( 0x7F7FFFFF ).value # >>> 340282346638528859811704183484516925440L (maximum float value)
    # looks like I've found a small bug o.o
    # the code still works though (the numbers are properly formatted)
    # the result SHOULD be: 3.4028234663852886e+38 (rounded)
    print fl( 0x3f80000000, 5 ).value # >>> 1.0

извините за небольшое ".value" в конце...
этот код использовался в качестве класса в моей программе в течение почти 2 лет.
(с небольшим редактированием, вы можете легко превратить это в функцию)

кредит на PyTony на DaniWeb для кода.

в отличие от нединамических вычислений,
код не жестко привязан к фиксированному размеру плавающего
и работает с любым размером байта.

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

хотя пока все хорошо...
У меня не было проблем с конвертированием 3D-моделей игр.:)

Источник

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

Источник
Другие вопросы по тегам