public final class Float extends Number implements Comparable<Float>, Constable, ConstantDesc {

    @java.io.Serial
    private static final long serialVersionUID = -2671257302660747028L; // 序列化版本号
    private final float value;                                  // 存储浮点数的值
    public static final float POSITIVE_INFINITY = 1.0f / 0.0f;  // 正无穷大常量
    public static final float NEGATIVE_INFINITY = -1.0f / 0.0f; // 负无穷大常量
    public static final float NaN = 0.0f / 0.0f;                // NaN常量
    public static final float MAX_VALUE = 0x1.fffffeP+127f;     // 最大值的常量
    public static final float MIN_VALUE = 0x0.000002P-126f;     // 最小值的常量
    public static final float MIN_NORMAL = 0x1.0p-126f;         // 最小的正常常量
    public static final int MAX_EXPONENT = 127;
    public static final int MIN_EXPONENT = -126;
    public static final int SIZE = 32;                          // 用bit表示的长度，4字节=32位
    public static final int BYTES = SIZE / Byte.SIZE;           // 用字节表示float
    public static final Class<Float> TYPE = (Class<Float>) Class.getPrimitiveClass("float");


    public int compareTo(Float anotherFloat) {}     // 当前浮点数和anotherFloat比较大小

    /**
     * 构造方法
     */
    @Deprecated(since="9")
    public Float(float value) {}
    @Deprecated(since="9")
    public Float(double value) {}
    @Deprecated(since="9")
    public Float(String s) throws NumberFormatException {}

    /**
     *
     */
    public boolean isNaN() {}       // 判断当前浮点数是否为 NaN
    public boolean isInfinite() {}  // 当前数是正无穷或负无穷则返回true，否则返回false
    public String toString() {}     // 浮点数转换成字符串
    public byte byteValue() {}      // 浮点数转换为byte
    public short shortValue() {}    // 浮点数转换short
    public int intValue() {}        // 浮点数转换为int
    public long longValue() {}      // 浮点数转换成long
    @HotSpotIntrinsicCandidate
    public float floatValue() {}    // 得到当前浮点数
    public double doubleValue() {}  // 浮点数转换成double
    @Override
    public int hashCode() {}        // 浮点数的hash值
    public boolean equals(Object obj) {}  // 当前浮点数是否于obj相等
    /**
     * 静态方法
     * 和上面非静态方法差不多意思，只不过上面的参数来自本身的value
     * 而下面是的方法是通过类名当做工具类使用的
     */
    public static int hashCode(float value) {}      //浮点数的hash值
    public static int compare(float f1, float f2){} // 比较两浮点数大小
    public static float sum(float a, float b) {}    // 两个浮点数求和
    public static float max(float a, float b) {}    // 两个浮点数最大的一个浮点数
    public static float min(float a, float b) {}    // 两个浮点数最小的一个浮点数
    public static String toString(float f) {}       // 浮点数转换成字符串
    public static String toHexString(float f) {}    // 浮点数转换成16进制字符串
    public static Float valueOf(String s) {}        // 字符串转浮点数对象
    @HotSpotIntrinsicCandidate
    public static Float valueOf(float f) throws NumberFormatException {}     // 将浮点数封装成Float对象
    public static float parseFloat(String s) throws NumberFormatException {} // 解析字符串为浮点数
    public static boolean isNaN(float v) {}         // 判断 v 是否为NaN类型，是则true，否则为false
    public static boolean isInfinite(float v) {}    // 判断 v 是否是正无穷或负无穷则返回true，否则返回false
    public static boolean isFinite(float f) {}      // f 有浮点值返回true，没有则返回false

    @HotSpotIntrinsicCandidate
    public static int floatToIntBits(float value) {} // 浮点数转换成2进制01表示的值
    @HotSpotIntrinsicCandidate
    public static native int floatToRawIntBits(float value);//
    @HotSpotIntrinsicCandidate
    public static native float intBitsToFloat(int bits); // 将int01表示的数据转换成float


    // 将Float封装在Optional容器内（允许null）
    @Override
    public Optional<Float> describeConstable() {
        return Optional.of(this);
    }
    @Override
    public Float resolveConstantDesc(MethodHandles.Lookup lookup) {
        return this;
    }
}

错误：

ValueError: could not convert string to float

出错的地方为：

month_diff = int(float(date_consumed[-6:-4])) - int(float(date_received[-6:-4])),这一句包含在函数get_time_diff中

我的目的是提取两个时间字符串里面的月份，然后计算月份差

出错的原因：

date_consumed或者date_received中含有空的字符串，

改正方式：

我在这里本意是将date_consumed和date_received中空的字符串去除，但是后来将这两个打印出来发现它们为空时用'nan'来表示了

frame = pd.Series(list(map(lambda x, y, z: 1. if x != 'null' and y != 'null' and z != 'null'and get_time_diff(z, y) <= 15 else 0., df[coupon_label], df[date_consumed_label], df[date_received_label])))

最终我将上面这句改成下面这句：

frame = pd.Series(list(map(lambda x, y, z: 1. if x != 'nan' and y != 'nan' and z != 'nan'and get_time_diff(z, y) <= 15 else 0., df[coupon_label], df[date_consumed_label], df[date_received_label])))

程序正常运行了！

文章目录
前言
精度限制
float存储方式
float存储示例
float范围
float精度
float小数
float特殊值
总结


前言
关于float的精度和取值范围这个问题，我查询了很多次，每次都是用完就忘了，等到再使用的时候还需要再次查询，关键是这个问题大家给出的结果并不都是一致的，我得从众多的资料当中选择出正确的观点，这还要额外花一些时间，所以我决定也总结一次，方便我以后拿来直接用了，如果能给大家带来帮助那就更好了。下面提到一些说法很多都是我个人的理解，如果大家有疑义，欢迎讨论。
精度限制
首先考虑下为什么会产生精度问题，是因为存储数据的空间有限，以一个四字节整数int n;为例，一共有32位，取值范围是 [-2147483648‬, 2147483647] ，一共是4,294,967,296种可能，它的精度可以说是小数点后一位都不保留，也就是只有整数，换句话说变量n可以表示实数范围内的4,294,967,296个数值。
如果换成float类型呢？一个变量float f所能表示多少个数呢？实际上由于存储空间未发生变化，同样是4字节32位，那么float类型也只能表示，或者说精确表示4,294,967,296个数值（真实情况由于一些特殊的规则，最终所表示的数字个数还要少），说到这里很多人可能会疑惑，因为他知道float可以表示比4,294,967,296大的数，同时也能表示小数，如果只有4,294,967,296种可能，那究竟是怎么做到的呢？
这里也就开始提到精度了，整数很好理解，每个数字的间隔都是1，int类型所表示的4,294,967,296个数字都是等间距的，步长为1。而float也只能表示4,294,967,296个数字，同时要表示比int还大的范围，一个很直观的想法就是把间距拉大，这样范围就大了，但是float还要表示小数，像0.2、0.4这样的数字间距明显要小于1啊，想要存储小数貌似要把间距缩小，这就和前面矛盾了啊。
实际上float类型存储数据的间隔不是等间距的，而是在0的附近间距小，在远离0的位置间距大，为什么会这样，一会我们看一下float类型数据的存储规则就明白了，这里先来看一下int类型和float类型所表示数字的范围对比，这只是一个示意图。
//int
           [ *         *         *         0         *         *         * ]
//float
[ *          *    *    *   *  *  * * * * * 0 * * * * *  *  *   *    *    *          * ]

上面的示意图就是两者表示数字范围的差异，每个星号*就表示一个数字，float通过这种不等间距的分布，既扩大了范围也表示了小数，那么有没有问题呢？
当然有问题，饭就这么多，人多了自然不够吃了，因为远离0的位置间距越来越大，当要表示间距中间的一个数字时，只能找它附近离它最近的一个可以表示的数字来代替，这就导致了精度问题，比如我给一个float类型变量分别赋值为 4294967244 和 4294967295 ，再次输出时都变成了 4294967296，因为超过了精度，所以只能找最接近的数字代替。
float存储方式
这部分内容基本上各篇文章说的都一致，我也简单描述下，后面根据这部分的定义来推算一下float的精度和取值范围。
首先我们知道常用科学计数法是将所有的数字转换成(±)a.b x $10^c$ 的形式，其中a的范围是1到9共9个整数，b是小数点后的所有数字，c是10的指数。而计算机中存储的都是二进制数据，所以float存储的数字都要先转化成(±)a.b x $2^c$，由于二进制中最大的数字就是1，所以表示法可以写成(±)1.b x $2^c$的形式，float要想存储小数就只需要存储(±)，b和c就可以了。
float的存储正是将4字节32位划分为了3部分来分别存储正负号，小数部分和指数部分的：

Sign（1位）：用来表示浮点数是正数还是负数，0表示正数，1表示负数。
Exponent（8位）：指数部分。即上文提到数字c，但是这里不是直接存储c，为了同时表示正负指数以及他们的大小顺序，这里实际存储的是c+127。
Mantissa（23位）：尾数部分。也就是上文中提到的数字b。

三部分在内存中的分布如下，用首字母代替类型




S
E
E
E
E
E
E
E
E
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M




0
1
0
0
0
0
0
0
1
1
0
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1
0
0
1
1


float存储示例
以数字6.5为例，看一下这个数字是怎么存储在float变量中的：


先来看整数部分，模2求余可以得到二进制表示为110。


再来看小数部分，乘2取整可以得到二进制表示为.1（如果你不知道怎样求小数的二进制，请主动搜索一下）。


拼接在一起得到110.1然后写成类似于科学计数法的样子，得到1.101 x $2^2$。


从上面的公式中可以知道符号为正，尾数是101，指数是2。


符号为正，那么第一位填0，指数是2，加上偏移量127等于129，二进制表示为10000001，填到2-9位，剩下的尾数101填到尾数位上即可






S
E
E
E
E
E
E
E
E
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M
M




0
1
0
0
0
0
0
0
1
1
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0



内存中二进制数01000000 11010000 00000000 00000000表示的就是浮点数6.5

float范围
明白了上面的原理就可求float类型的范围了，找到所能表示的最大值，然后将符号为置为1变成负数就是最小值，要想表示的值最大肯定是尾数最大并且指数最大，

那么可以得到尾数为 0.1111111 11111111 11111111，指数为 11111111，但是指数全为1时有其特殊用途，所以指数最大为 11111110，指数减去127得到127，所以最大的数字就是1.1111111 1111111 11111111 x $2^{127}$，这个值为 340282346638528859811704183484516925440，通常表示成 3.4028235E38，那么float的范围就出来了：

[-3.4028235E38, 3.4028235E38]

float精度
float 类型的数据精度取决于尾数，相信大家都知道这一点，但是精度怎么算我也是迷糊了好久，最近在不断尝试的过程中渐渐的明白了，首先是在不考虑指数的情况下23位尾数能表示的范围是[0, $2^{23}-1$]，实际上尾数位前面还隐含了一个"1"，所以应该是一共24位数字，所能表示的范围是[0, $2^{24}-1$]（因为隐含位默认是"1"，所以表示的数最小是1不是0，但是先不考虑0，后面会特殊介绍，这里只按一般值计算），看到这里我们知道这24位能表示的最大数字为$2^{24}$-1，换算成10进制就是16777215，那么[0, 16777215]都是能精确表示的，因为他们都能写成1.b x $2^c$的形式，只要配合调整指数c就可以了。
16777215 这个数字可以写成1.1111111 11111111 1111111 * $2^{23}$，所以这个数可以精确表示，然后考虑更大的数16777216，因为正好是2的整数次幂，可以表示1.0000000 00000000 00000000 * $2^{24}$，所以这个数也可以精确表示，在考虑更大的数字16777217，这个数字如果写成上面的表示方法应该是 1.0000000 00000000 00000000 1 * $2^{24}$，但是这时你会发现，小数点后尾数位已经是24位了，23位的存储空间已经无法精确存储，这时浮点数的精度问题也就是出现了。
看到这里发现 16777216 貌似是一个边界，超过这个数的数字开始不能精确表示了，那是不是所有大于16777216的数字都不能精确表示了呢？其实不是的，比如数字 33554432 就可以就可以精确表示成1.0000000 00000000 00000000 * $2^{25}$，说道这里结合上面提到的float的内存表示方式，我们可以得出大于 16777216 的数字（不超上限），只要可以表示成小于24个2的n次幂相加，并且每个n之间的差值小于24就能够精确表示。换句话来说所有大于 16777216 的合理数字，都是[0, 16777215]范围内的精确数字通过乘以$2^n$得到的，同理所有小于1的正数，也都是 [0, 16777215] 范围内的精确数字通过乘以$2^n$得到的，只不过n取负数就可以了。
16777216 已经被证实是一个边界，小于这个数的整数都可以精确表示，表示成科学技术法就是1.6777216 * $10^{7}$，从这里可以看出一共8位有效数字，由于最高位最大为1不能保证所有情况，所以最少能保证7位有效数字是准确的，这也就是常说float类型数据的精度。
float小数
从上面的分析我们已经知道，float可表示超过16777216范围的数字是跳跃的，同时float所能表示的小数也都是跳跃的，这些小数也必须能写成2的n次幂相加才可以，比如0.5、0.25、0.125…以及这些数字的和，像5.2这样的数字使用float类型是没办法精确存储的，5.2的二进制表示为101.0011001100110011001100110011……最后的0011无限循环下去，但是float最多能存储23位尾数，那么计算机存储的5.2应该是101.001100110011001100110，也就是数字 5.19999980926513671875，计算机使用这个最接近5.2的数来表示5.2。关于小数的精度与刚才的分析是一致的，当第8位有效数字发生变化时，float可能已经无法察觉到这种变化了。
float特殊值
我们知道float存储浮点数的形式是(±)1.b x $2^c$，因为尾数位前面一直是个1，所以无论b和c取什么样的值，都无法得到0，所以在float的表示方法中有一些特殊的约定，用来表示0已经其他的情况。
float的内存表示指数位数有8位，范围是[0, 255]，考虑偏移量实际的指数范围是[-127,128]，但实际情况下指数位表示一般数字时不允许同时取0或者同时取1，也就是指数位的实际范围是[-126,127]，而指数取-127和128时有其特殊含义，具体看下面表格：




符号位
指数位
尾数位
数值
含义




0
全为0
全为0
+0
正数0


1
全为0
全为0
-0
负数0


0
全为0
任意取值f
$0.f * 2^{-126}$
非标准值，尾数前改为0，提高了精度


1
全为0
任意取值f
$-0.f * 2^{-126}$
非标准值，尾数前改为0，提高了精度


0
全为1
全为0
+Infinity
正无穷大


1
全为1
全为0
-Infinity
负无穷大


0/1
全为1
不全为0
NaN
非数字，用来表示一些特殊情况


总结

float的精度是保证至少7位有效数字是准确的
float的取值范围[-3.4028235E38, 3.4028235E38]，精确范围是[-340282346638528859811704183484516925440, 340282346638528859811704183484516925440]
一个简单的测试float精度方法，C++代码中将数字赋值给float变量，如果给出警告warning C4305: “=”: 从“int”到“float”截断，则超出了float的精度范围，在我的测试中赋值为16777216及以下整数没有警告，赋值为16777217时给出了警告。

本文只讨论float转int的原理，如有不当之处，欢迎留言指出。交流学习。 


推荐阅读关于float转int的函数实现（非结构体实现版） 类型强转丢失精度的根源

目录

一、思路

1.1 十进制

1.2 二进制

1.3 处理棘手的符号位

1.4 小端模式

二、C语言实现

2.1 思路

2.2 利用结构体实现

2.3 利用内存拷贝函数memcpy实现

一、思路

1.1 十进制

大体和科学计数法（小数点前面只有1位，和用什么进制实现没有关系）别无二致。如果十进制：




从图1 我们可以看到， 对于科学计数法而言，小数点前面只有1位、小数点后面是有效位、以10为底数的幂有正有负有0。那么为了记录一个十进制数，我们需要记录四个要素：符号、小数点前的一位、有效位、指数。

1.2 二进制

类比到二进制，小数点前面一位一定是1，正如十进制小数点前面一位一定是1-9一样；那么我们只需记录符号、有效位以及指数。下面我们先举一个例子：-12,25展成float。注意：此处不要去想表示整型的原码反码补码那一套了。正如稍前讨论的那般，指数是有正负的，那如果不加某种手段，如何表示指数的正负呢？

1.3 处理棘手的符号位

IEEE二进制浮点数算术标准（ANSI/IEEE Std 754-1985）告诉我们一个很棒的解决办法：是这样做的，选取8bite用于表示指数部分（底数是2），有256种变化，既可以理解为0-255也可以理解为-128-127，取决于设计者是如何去解释的。而后者是非常好的，正指数和负指数都是127一人一半。所以不管实际指数是多少，一律加上127类似于加密过程；等到想把真实值取出来的时候，一律减去127类似于解密过程。

现在来演算一下-12.25如何展成float吧：




最后我们才能大体看懂这张示意图：




1.4 小端模式

大端模式和小端模式的由来

二、C语言实现

2.1 思路

难点在于如何用一个变量去读出内存中存放的float类型的变量。最直接的办法就是按照float类型的结构去设计一个完全一致的结构体，更为巧妙的办法是将float类型的变量通过调用内存拷贝函数memcpy复制到unsigned long类型的变量中。这两种办法都能将float类型的变量取出，然后分别读取符号位、指数位、尾数有效位。

学无止境，下面分别讨论这两种思路的实现：

2.2 利用结构体实现

用到了位域的知识点：




结构体设计以及函数声明。

#include<stdio.h> //printf()
#include<stdlib.h> //atof()

typedef struct FloatNode
{
    unsigned int mantissa : 23; //尾数部分
    unsigned int exponent : 8; //指数部分
    unsigned int sign : 1;  //符号位
}FloatNode;

int GetSign(const FloatNode *fn); //获取符号位
int GetExp(const FloatNode *fn); //获取指数部分
int Float_To_Int(float num); //类型强制转换

其他函数的实现

int GetSign(const FloatNode *fn) //获得符号位
{
    return fn->sign == 1 ? -1 : 1;
}

int GetExp(const FloatNode *fn) //获得指数位
{
    return (fn->exponent - 127); //根据IEEE754,减去127才是真正的指数位
}

int Float_To_Int(float num) //将float强转成int
{
    FloatNode *fn = (FloatNode*)&num;
    int exp = GetExp(fn);

    if(exp >= 0)
    {
        int mov = 23 - exp;
        int res = (fn->mantissa | 1<<23) >> mov;
        return res*GetSign(fn);
    }
    else
    {
        return 0;
    }
}

main主函数

int main(int argc, char* argv[])
{
    if(argc <= 1)
    {
        printf("%s\n", "Argument isn't enough.");
        return 0;
    }
    char *p = argv[1];
    float num = atof(p);
    int res = Float_To_Int(num);
    printf("转换之后的结果是：%d\n", res);
    return 0;
}




2.3 利用内存拷贝函数memcpy实现

重要的话，浮点型没有移位运算，或者说，即使强行进行移位运算也是被当成整型对待而得到错误的结果。如果不用一个和float类型完全一致的结构体去读取，那么只能将float类型的数据放到unsigned类型中再进行操作。

实际上就是对float型的结构进行解析，尤要注意的是运算符的优先级，告诫本篇博客的博友们：不要止步于看懂，自己也要写一写。

库文件的引入及函数的声明：

#include<stdio.h> //printf()
#include<string.h> //memcpy()
#include<stdlib.h> //atof()

int getSign(unsigned num);      //获得符号位
int getExp(unsigned num);       //获得指数部分
int float2int(float ft);    //float强转为int

其他函数的实现

int getSign(unsigned num)       //获得符号位
{
    int sign = num & (1<<31);
    return sign == 0 ? 1 : -1; 
}

int getExp(unsigned num)        //获得指数部分
{
    int exp = 0;
    for(int i = 23; i < 31; ++i)
        exp |= (num & (1<<i));
    exp = (exp>>23) - 127;
    return exp;
}

int float2int(float ft) //float强转为int
{
    unsigned num;
    memcpy(&num, &ft, sizeof(float)); //将float数据完整地拷贝到unsigned中

    int exp = getExp(num); //获得float存储结构的指数部分
    if(exp < 0) //如果指数小于0的话，实际值肯定是0.***,故而强转之后就为0
    {
        return 0;
    }
    else
    {
        int res = num & ((1<<23)-1);  //保留mantissa 注意运算符的优先级
        res |= 1<<23;   //将小数点前的1补上
        res >>= (23-exp); //整数部分右移到合适位置
        return res*getSign(num);
    }
}

main主函数

int main(int argc, char * argv[])
{
    if(argc <= 1)
    {
        printf("augument is not enough.\n");
        return 0;
    }

    float ft = atof(argv[1]); //将字符串转化为同值的float
    int res = float2int(ft);
    printf("转换之后的结果是：%d\n", res);
    return 0;
}

运行结果：