如何将字符串作为 32 位浮点数的二进制 IEEE 754 表示？
例子
1.00 -> '00111111100000000000000000000000'
问问题
91240 次
13 回答
81
你可以用这个struct包做到这一点：
import struct
def binary(num):
return ''.join('{:0>8b}'.format(c) for c in struct.pack('!f', num))
这会将其打包为网络字节顺序浮点数，然后将每个生成的字节转换为 8 位二进制表示并将它们连接起来：
>>> binary(1)
'00111111100000000000000000000000'
编辑：有人要求扩展解释。我将使用中间变量来扩展它来评论每个步骤。
def binary(num):
# Struct can provide us with the float packed into bytes. The '!' ensures that
# it's in network byte order (big-endian) and the 'f' says that it should be
# packed as a float. Alternatively, for double-precision, you could use 'd'.
packed = struct.pack('!f', num)
print 'Packed: %s' % repr(packed)
# For each character in the returned string, we'll turn it into its corresponding
# integer code point
#
# [62, 163, 215, 10] = [ord(c) for c in '>\xa3\xd7\n']
integers = [ord(c) for c in packed]
print 'Integers: %s' % integers
# For each integer, we'll convert it to its binary representation.
binaries = [bin(i) for i in integers]
print 'Binaries: %s' % binaries
# Now strip off the '0b' from each of these
stripped_binaries = [s.replace('0b', '') for s in binaries]
print 'Stripped: %s' % stripped_binaries
# Pad each byte's binary representation's with 0's to make sure it has all 8 bits:
#
# ['00111110', '10100011', '11010111', '00001010']
padded = [s.rjust(8, '0') for s in stripped_binaries]
print 'Padded: %s' % padded
# At this point, we have each of the bytes for the network byte ordered float
# in an array as binary strings. Now we just concatenate them to get the total
# representation of the float:
return ''.join(padded)
几个例子的结果：
>>> binary(1)
Packed: '?\x80\x00\x00'
Integers: [63, 128, 0, 0]
Binaries: ['0b111111', '0b10000000', '0b0', '0b0']
Stripped: ['111111', '10000000', '0', '0']
Padded: ['00111111', '10000000', '00000000', '00000000']
'00111111100000000000000000000000'
>>> binary(0.32)
Packed: '>\xa3\xd7\n'
Integers: [62, 163, 215, 10]
Binaries: ['0b111110', '0b10100011', '0b11010111', '0b1010']
Stripped: ['111110', '10100011', '11010111', '1010']
Padded: ['00111110', '10100011', '11010111', '00001010']
'00111110101000111101011100001010'
于 2013-05-08T15:40:01.217 回答
40
这是一个丑陋的...
>>> import struct
>>> bin(struct.unpack('!i',struct.pack('!f',1.0))[0])
'0b111111100000000000000000000000'
基本上，我只是使用 struct 模块将 float 转换为 int ...
这是一个稍微好一点的使用ctypes：
>>> import ctypes
>>> bin(ctypes.c_uint.from_buffer(ctypes.c_float(1.0)).value)
'0b111111100000000000000000000000'
基本上，我构造 afloat并使用相同的内存位置，但我将其标记为c_uint. 的c_uint值是一个 python 整数，您可以在其上使用内置bin函数。
于 2013-05-08T15:40:24.340 回答
30
使用bitstring模块找到了另一个解决方案。
import bitstring
f1 = bitstring.BitArray(float=1.0, length=32)
print(f1.bin)
输出：
00111111100000000000000000000000
于 2013-06-10T10:10:16.320 回答
12
为了完整起见，您可以使用 numpy 实现此目的：
f = 1.00
int32bits = np.asarray(f, dtype=np.float32).view(np.int32).item() # item() optional
b然后，您可以使用格式说明符使用填充打印此内容
print('{:032b}'.format(int32bits))
于 2016-10-25T21:17:20.037 回答
10
通过将其分为两部分，可以更干净地处理此问题。
第一种是将浮点数转换为具有等效位模式的 int：
import struct
def float32_bit_pattern(value):
return sum(ord(b) << 8*i for i,b in enumerate(struct.pack('f', value)))
Python 3 不需要ord将字节转换为整数，因此您需要稍微简化一下上述内容：
def float32_bit_pattern(value):
return sum(b << 8*i for i,b in enumerate(struct.pack('f', value)))
接下来将 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'
于 2013-05-08T16:18:47.267 回答
9
使用这两个简单的函数 ( Python >=3.6 )，您可以轻松地将浮点数转换为二进制数，反之亦然，适用于 IEEE 754 binary64。
import struct
def bin2float(b):
''' Convert binary string to a float.
Attributes:
:b: Binary string to transform.
'''
h = int(b, 2).to_bytes(8, byteorder="big")
return struct.unpack('>d', h)[0]
def float2bin(f):
''' Convert float to 64-bit binary string.
Attributes:
:f: Float number to transform.
'''
[d] = struct.unpack(">Q", struct.pack(">d", f))
return f'{d:064b}'
例如：
print(float2bin(1.618033988749894))
print(float2bin(3.14159265359))
print(float2bin(5.125))
print(float2bin(13.80))
print(bin2float('0011111111111001111000110111011110011011100101111111010010100100'))
print(bin2float('0100000000001001001000011111101101010100010001000010111011101010'))
print(bin2float('0100000000010100100000000000000000000000000000000000000000000000'))
print(bin2float('0100000000101011100110011001100110011001100110011001100110011010'))
输出是：
0011111111111001111000110111011110011011100101111111010010100100
0100000000001001001000011111101101010100010001000010111011101010
0100000000010100100000000000000000000000000000000000000000000000
0100000000101011100110011001100110011001100110011001100110011010
1.618033988749894
3.14159265359
5.125
13.8
我希望你喜欢它，它非常适合我。
于 2020-01-04T21:12:53.993 回答
5
用 Python3 的彩色版本对 Dan 的回答进行小猪尾巴：
import struct
BLUE = "\033[1;34m"
CYAN = "\033[1;36m"
GREEN = "\033[0;32m"
RESET = "\033[0;0m"
def binary(num):
return [bin(c).replace('0b', '').rjust(8, '0') for c in struct.pack('!f', num)]
def binary_str(num):
bits = ''.join(binary(num))
return ''.join([BLUE, bits[:1], GREEN, bits[1:10], CYAN, bits[10:], RESET])
def binary_str_fp16(num):
bits = ''.join(binary(num))
return ''.join([BLUE, bits[:1], GREEN, bits[1:10][-5:], CYAN, bits[10:][:11], RESET])
x = 0.7
print(x, "as fp32:", binary_str(0.7), "as fp16 is sort of:", binary_str_fp16(0.7))
于 2020-02-24T21:29:35.247 回答
2
在浏览了很多类似的问题之后，我写了一些希望能达到我想要的东西。
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
如果为负，则将数字转换为正数，并将变量负数设置为假。这样做的原因是正负二进制表示之间的区别仅在第一位，这是比在使用负数执行整个过程时找出问题所在更简单的方法。
s = struct.pack('>f', f) #'?\x80\x00\x00'
p = struct.unpack('>l', s)[0] #1065353216
hex_data = hex(p) #'0x3f800000'
s是二进制的十六进制表示f。然而，它不是我需要的漂亮形式。这就是 p 的用武之地。它是十六进制 s 的 int 表示。然后进行另一次转换以获得漂亮的十六进制。
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从这个问题得到代码。如果数字是负数，只需更改第一位。
我知道这很丑陋，但我没有找到一个好的方法，我需要它快。欢迎评论。
于 2013-05-08T15:50:24.257 回答
2
这比要求的要多一点，但这是我找到此条目时所需要的。此代码将给出 IEEE 754 32 位浮点数的尾数、基数和符号。
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
于 2016-11-11T13:04:14.603 回答
1
在 0..1 之间转换浮点数
def float_bin(n, places = 3):
if (n < 0 or n > 1):
return "ERROR, n must be in 0..1"
answer = "0."
while n > 0:
if len(answer) - 2 == places:
return answer
b = n * 2
if b >= 1:
answer += '1'
n = b - 1
else:
answer += '0'
n = b
return answer
于 2019-12-29T02:28:34.750 回答
0
其中一些答案不能像用 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) )
于 2016-09-23T19:01:08.657 回答
0
我做了一个非常简单的。请检查一下。如果您认为有任何错误，请告诉我。这对我来说很好。
sds=float(input("Enter the number : "))
sf=float("0."+(str(sds).split(".")[-1]))
aa=[]
while len(aa)<15:
dd=round(sf*2,5)
if dd-1>0:
aa.append(1)
sf=dd-1
else:
sf=round(dd,5)
aa.append(0)
des=aa[:-1]
print("\n")
AA=([str(i) for i in des])
print("So the Binary Of : %s>>>"%sds,bin(int(str(sds).split(".")[0])).replace("0b",'')+"."+"".join(AA))
或者如果是整数，只需使用bin(integer).replace("0b",'')
于 2021-07-12T18:17:20.880 回答
-1
在我看来，您可以使用 .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'
于 2016-03-01T02:44:05.980 回答