How do I read this floating point representation?

I am using the struct module to obtain the binary representation of a floating point number. However, I have some trouble in making sense of the output

import struct
def fl_bin(fl):
    s = struct.pack('!f', fl)
    b = ''.join(format(c, '08b') for c in s)
    print(b) # whole representation
    print("Exponent: {}".format(b[1:9])) # Exponent only
    return b[9:] # significant

a = fl_bin(2.1)

The call gives an exponent of 10000000 and a significant of 00001100110011001100110.
My reasoning was as follows: The length of the representation is 32, hence it should be the single precision format. The first bit should indicate the sign, the next 8 bits the exponent (and the rest for the significant).
However, if this is true, I don't really see how to obtain the original number from this. For instance, for the exponent I read: 1 -> positive, 000000 -> 1 as exponent. But then I am stuck making sense of the significant. Maybe someone could elaborate on this issue!

Floating point representations use IEEE 754 standard, in this case binary32 format.
Reading specification for that, you can learn that in binary representation you have:

• Sign bit: 1 bit
• Exponent width: 8 bits
• Significand precision: 24 bits (23 explicitly stored)

Exponent is biased, meaning you have to subtract bias of 127 to get the actual number. This gives us an exponent of 1 in your example.

The significant is stored with only a fractional part, with implicit 1 leading it. Thus, we get a binary number of 1.00001100110011001100110. Plugging that to bin -> dec converter, we get a value of 1.0499999523162841796875.

Taking all of those together, 1.0499999523162841796875 * 2 ^ 1 = 2.099999904632568359375 which is close enough to our original 2.1

To interpret the exponent field, take its value as a eight-bit unsigned binary numeral and subtract 127.

As a binary numeral, “10000000” represents 128. Subtracting 127 yields 1. So “10000000” represents an exponent of 1.

Full interpretation of IEEE-754 binary32 encodings:

• Let S be the bit in the sign field. Let E be the eight bits in the exponent field, interpreted as an unsigned binary numeral. Set F be the 23 bits in the primary significand field, interpreted as an unsigned binary numeral.
• NaN: If E is 255 (all one bits) and F is not 0, the floating-point datum is a NaN. Preferably, a QNaN has the leading bit of the significand field set and a signaling NaN has it clear, but this is not required by IEEE 754.
• Infinite: If E is 255 and F is 0, the datum is (−1)^S•∞, that is, +∞ if S is 0 and −∞ if S is 1.
• Normal: If E is neither 255 nor 0, the datum is (−1)^S•(1+F•2⁻²³)•2^E−127. In other words, move F to the right of the radix point (a generalized decimal point), put 1 on the left, scale by the exponent (adjusted by the bias), and apply the sign.
• Subnormal: If E is 0 and F is not 0, the datum is (−1)^S•(0+F•2⁻²³)•2¹⁻¹²⁷. In other words, move F to the right of the radix point, put 0 on the left, scale as if the exponent field were 1 (not 0), and apply the sign. Note that since the exponent is taken as 1, this means subnormals have the same scaling as the lowest normals—they decreased by changing the leading digit from 1 to 0 rather than by decreasing the exponent.
• Zero: If E is 0 and F is 0, the datum is (−1)^S•0. Note that IEEE 754 distinguishes +0 and −0. (Zero can also be interpreted using the formula for subnormals. It is merely distinguished as a special value due to its mathematical significance.)