浅谈Python里面None True False之间的区别

None虽然跟True False一样都是布尔值。

虽然None不表示任何数据，但却具有很重要的作用。

它和False之间的区别还是很大的！

例子：

>>> t = None
>>> if t:
... print("something")
... else:
... print("nothing")
...
nothing

区分None和False.使用is来操作！

>>> if t is None:
... print("this is None!")
... else:
... print("this is ELSE!")
...
this is None!
>>>

虽然是个小小的区别！但是在Python里面是重要的。你需要将None和不含任何值的空数据结构区分开。

0值的整型/浮点型，空字符串（‘ '），空列表（[]）,空元组（{}），空集合（set()）都是等价于False,但是不等于None。

现在，写一个函数：

>>> def oj(t):
... if t is None:
... print("this is None")
... elif t:
... print("this is True")
... else:
... print("this is False")
...

进行数据测验：

>>> oj(None)
this is None
>>> oj(True)
this is True
>>> oj(False)
this is False
>>> oj(0)
this is False
>>> oj(0.0)
this is False
>>> oj([])
this is False
>>> oj(())
this is False
>>> oj({})
this is False

以上说明，None，False,True还是有很大不同的~

补充知识：python "0.3 == 3 * 0.1" 为False的原因

一.引入

如果你在你的解释器中输入以下第一行代码：

>>> 0.3 == 3 * 0.1

False

你会发现，输出为False。

对于CS小白而言，对此表示费解。

因此我查了相关的资料，进行了一下总结。

二.浮点算法的问题和局限

1.计算机硬件对于浮点数的处理方式

首先，我们必须明白一件事情。浮点数在计算机硬件中表示为基数2（二进制）的分数。

例如：

0.125(10) == 1/10 + 2/100 + 5/1000

0.001(2) == 0/2 + 0/4 + 0/8

这两个分数具有相同的值，唯一的实际区别是，第一个分数以10为基数的分数表示，第二个分数以2为基数。当我们输入0.125时，计算机硬件会以第二种方式表示，而不是第一种。

但是不幸的是，大多数十进制分数不能完全表示为二进制分数。

结果是，通常我们输入的十进制浮点数仅由计算机中实际存储的二进制浮点数

近似。但是在十进制不能完全表示为二进制分数的情况下，无论多么近似，终究不是确切值。

2.例子：对于0.1的处理

例如0.1(10)，无论我们愿意使用多少个2位数字，十进制值0.1都不能精确表示为2进制小数，即以2为底的1/10是无限重复的分数。

0.1(10) == 0.0001100110011001100110011001100110011001100110011...(2)

当我们让它停在某个有限的位数，就可以得出一个近似值。

因为Python浮点数可使用 53位精度 ，

因此输入十进制数时计算机内部存储的值0.1是

0.00011001100110011001100110011001100110011001100110011010(2)

这个值接近但是不等于1/10.

这也是造成print(0.3 == 3 * 0.1)输出为False的原因。

如果要强制使用python输出计算机内保存的0.1的真实十进制值，应该为

>>> 0.1

0.1000000000000000055511151231257827021181583404541015625

由于这一串数字实在太长了，所以Python通过显示舍入的值来保持数字的可管理性。所以实际上我们看到是：

>>> 0.1

0.1

但是我们要明白，机器中的值不完全是1/10，这只是舍入了真实机器值的显示。

3.一点有趣的东西

上面我们提到了Python通过显示舍入的值来保持数字的可管理性，我们看到的只是舍入了真实机器值的显示。通过下面的例子，我们就可以更加清楚这一事实。

当我们用python写下下面的代码时，就会发现这个神奇的现象。

这本质上是二进制浮点数：这不是Python中的bug，也不是代码中的bug。在支持硬件浮点算术的所有语言中，都会看到同一种东西（尽管某些语言在默认情况下或在所有输出模式下可能不会显示差异）。

1）0.1+0.2

>>> 0.1 + 0.2

0.30000000000000004

2）round(2.675， 2)

i)round( x [, n] )的用法

作用： 返回浮点数x的四舍五入值。

参数：

x – 数值/数值表达式。

n – 要保留的小数位数，可以省略。若省略，n默认为0，即四舍五入到整数。

ii)round( 2.675, 2)

按照我们的逻辑来看，输入round( 2.675, 2 )，输出应该为2.68。但是实际上是：

>>> round(2.675, 2)

2.67

三.表示错误（选读）

在这里我们详细说明“ 0.1”示例，并说明我们如何自己对此类情况进行准确的分析。如果你不想深究其背后的原因，下面的可以忽略。

1.表示错误的概念、影响和原因

(1)概念

表示错误是指某些（在实际中为大多数）小数部分不能完全表示为二进制（基数为2）分数。

(2)影响

使得Python（或Perl，C，C ++，Java，Fortran和其他许多语言）经常不显示我们所期望的确切十进制数字。

(3)原因

如今，几乎所有机器都使用IEEE-754浮点算法，并且几乎所有平台都将Python浮点数映射到IEEE-754“双精度”。754个double包含53位精度，因此在输入时，计算机会努力将浮点数转换为J / 2 ** N形式的最接近分数， 其中J是一个正好包含53位的整数。

2."0.1"的具体分析

转化目标：1 / 10 ~= J / (2 ** N)

所以：J ~= 2 ** N / 10

1)求解N

因为J是一个正好包含53位的整数(但是实际上最后我们用的是J的近似值( >=2 ** 52 and < 2 ** 53)是通过N计算出来的)，并且N是一个整数，所以我们可以得到N的最佳值是56

>>> 2**52
4503599627370496
>>> 2**53
9007199254740992
>>> 2**56/10
7205759403792793

2)求解我们要用的J的近似值

我们通过N来求解实际的J，我们实际上用的J其实是(2**N /10)四舍五入之后的值。

i)divmod(a, b)

功能： 接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b)。

参数：

a – 被除数

b – 除数

ii)求解J近似值

>>> q, r = divmod(2**56, 10)
>>> r
6

因为余数为6>5,所以我们用的J的近似值是

>>> q+1

7205759403792794

3)求解"0.1"的近似值

因此，在754倍精度中，最接近1/10的最佳近似值是

7205759403792794 / 72057594037927936

【注】由于我们四舍五入，因此实际上比1/10大一点；如果我们不进行四舍五入，则商将小于1/10。但是在任何情况下都不能完全是 1/10！

4)获取计算机存储值

通过上面的分析，我们可以看到计算机永远不会“看到” 1/10：它看到的是上面给出的精确分数，它可以得到的最佳754倍近似值(即J的近似值)

>>> .1 * 2**56

7205759403792794.0

如果我们将该分数乘以10 ** 30，我们可以看到其30个最高有效十进制数字的（截断）值：

>>> 7205759403792794 * 10**30 // 2**56

100000000000000005551115123125L

在Python 2.7和Python 3.1之前的版本中，Python将该值四舍五入为17个有效数字，即为'0.10000000000000001'。

在最新版本中，Python会基于最短的十进制分数显示一个值，该值会正确舍入为真实的二进制值，并仅得出'0.1'。

以上这篇浅谈Python里面None True False之间的区别就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持猪先飞。