Convert Floating to Binary - Python

The task of converting a floating-point number to its binary representation in Python involves representing the number in the IEEE 754 format, which consists of a sign bit, an exponent and a mantissa. For example, given the floating-point number 10.75, its IEEE 754 32-bit binary representation is "01000001001011000000000000000000".

Using struct module

struct module is the fastest way to convert a float to binary as it directly interacts with memory using Python’s C-based internal implementation. It packs the float into IEEE 754 format and extracts its binary representation efficiently. This method is widely used in system-level programming and performance-critical applications.

import struct
n = 10.75
res = struct.unpack('!I', struct.pack('!f', n))[0]
print(f"{res:032b}")

01000001001011000000000000000000

Explanation: struct.pack('!f', n) to convert the float 10.75 into a 4-byte (32-bit) IEEE 754 binary format in big-endian order. Then, struct.unpack('!I', ...) interprets these bytes as a 32-bit unsigned integer, giving a numeric value that represents the binary data. Finally, f"{res:032b}" formats this integer as a 32-bit binary string.

Using NumPy

numpy provides a fast and vectorized way to obtain the binary representation of floating-point numbers. This method is extensively used in machine learning, numerical computing, and scientific analysis, where speed and efficiency are important . It directly converts a float to binary using numpy.float32 and bitwise operations

import numpy as np
n = 10.75
res = np.binary_repr(np.float32(n).view(np.int32), width=32)
print(res)

01000001001011000000000000000000

Explanation: First, np.float32(n) ensures the number is treated as a 32-bit floating point. Then, .view(np.int32) reinterprets its memory as a 32-bit integer without changing the bits. Finally, np.binary_repr(..., width=32) converts this integer into a 32-bit binary string .

Using IEEE 754 bit manipulation

This method manually extracts the sign, exponent and mantissa of a floating-point number and converts it to its binary IEEE 754 representation. It is useful for educational purposes, debugging floating-point operations and understanding how numbers are stored in memory. While less efficient than struct or numpy, it provides a clear breakdown of the conversion process.

n = 10.75
sign = '0' if n >= 0 else '1'
n= abs(n)
# get integer and fractional parts
int_part = int(n)
frac_part = n - int_part
# convert integer part to binary
int_bin = bin(int_part)[2:]
# convert fractional part to binary
frac_bin = []
while frac_part and len(frac_bin) < 23:
    frac_part *= 2
    bit = int(frac_part)
    frac_bin.append(str(bit))
    frac_part -= bit
# normalize
exponent = len(int_bin) - 1
mantissa = int_bin[1:] + ''.join(frac_bin)
# adjust mantissa to 23 bits
mantissa = (mantissa + '0' * 23)[:23]
# exponent with bias (127)
exponent_bin = f"{exponent + 127:08b}"
# IEEE 754 Binary Representation
res = sign + exponent_bin + mantissa
print(res)

01000001001011000000000000000000

Explanation: This code extracts the sign bit (0 for positive, 1 for negative) and splits the number into integer (10) and fractional (0.75) parts. The integer part is converted using bin(), while the fractional part is derived by multiplying by 2 and extracting bits. The exponent is determined from the integer's leftmost 1, biased by 127 and stored as 8 bits. The mantissa is adjusted to 23 bits. Finally, the IEEE 754 binary is formed as sign + exponent + mantissa.