How we got exponent as \$2^{127-64}\$?
The exponent is biased so that the format can better represent fractional numbers between 0 and 1. It's a way to extend the lower extent in range of precision that the format can handle. It turns out that values from 0 to 1 are quite important in most floating point calculation, more important than representing bigger magnitudes, so sacrificing half the upper range is a reasonable trade-off.

But there's another, more important reason for using bias (as opposed to 2’s complement) that I'll get to later, a reason that goes back to the very beginnings of floating point.

Anyway, in this format you basically have these key values and ranges:

 - zero                                 (sign, exp 0x00-64, mant 0.0x00)
 - denormals                            (sign, exp 0x00-64, mant 0.0x01 ~ 0.0xff)
 - smallest normalized less than one    (sign, exp 0x01-64, mant 1.0x00)
 - largest nomalized less than one      (sign, exp 0x3e-64, mant 1.0xff)
 - one                                  (sign, exp 0x3f-64, mant 1.0x00)
 - smallest normalized greater than one (sign, exp 0x40-64, mant 1.0x00)
 - largest normalized greater than one  (sign, exp 0x7f-64, mant 1.0xff)


Some fine points:


For all the cases except zero and denormal, the mantissa value is 1.mant, which gives a range of 1 to just 1 mantissa LSB less than 2 (that is, 1 + 0/256 to 1 + 255/256).
Because of the way sign is handled, there are two representations of zero: +0 and -0.


This example format is something like what IEEE754 does. IEEE754 also reserves special values for -infinity, +infinity, and not-a-number (NaN). Play around with it here: https://www.h-schmidt.net/FloatConverter/IEEE754.html



And now, the buried lede: Why use bias at all? Because it avoids needing to use 2's complement in the exponent, which would make simple greater- and less-than comparisons between float values harder.

With bias, you can do a magnitude compare with just a single integer subtract of the mantissa and exponent fields (sign bit is masked off and handled separately.) That’s not possible if 2’s were used for the exponent, as negative exponents would look like large integer values to an integer compare, giving a wrong result.

In other words, a biased exponent yields an always-increasing integer value from zero to positive infinity. (Try it in that app I linked.)

The side-effect of using bias is that it complicates float-to-fixed and fixed-to-float, but this is usually a rare operation that in any event is efficiently dealt with by the FPU.

And I mentioned a history of bias. The IBM 709 used biased exponents, way back in 1957, as did its predecessor, the 704, in 1954.