0 前言

数据分析师在使用python进行数据分析时，经常会遇到 Nan 和 None 这两个数据缺失值，但它们两并不互相等价，有很多细微的差别。笔者将在下面对 Nan 和 None 进行细致的介绍。

1 什么是 Nan 和 None ？

Nan （not a number） 和 None 都是 python 里的数据缺失值，表示当前某些数据为“空”。

数据缺失值 指现有数据集中某个或某些属性的值存在 不完全的空值 。

更准确的说， Nan 是出现在 numpy / pandas 里的缺失值，而 None 是 Python 的缺失值。某种意义上，None 是比 Nan 更高级、更彻底的空值。

2 Nan 和 None 的异同点

我们可以通过数据本身、其他类型函数、pandas等方面来比对。

2.1 数据本身

数据类型？

type(None) # NoneType
type(np.nan) # float
我们可以很直接的看到，在 python 里 None 是有着自己的独特类型（NoneType）,而 Nan 则是属于 float 类型。
Nan 因为自身属于浮点数（特殊的float），从而能够参加部分运算。但 None 则不能参与任何运算。
None == None # TRUE
None == np.nan # False
np.nan == np.nan # False
np.nan is np.nan # True
id(np.nan) == id(np.nan) # True
可以看到在这里，None 和 Nan 的表现也是不同的。
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
a is b 相当于 id(a)==id(b)，id() 能够获取对象的内存地址。
为什么 np.nan == np.nan 结果是 False，这涉及到 python 的另一个坑，有兴趣的同学可以参考这里
2.2 可迭代对象的表现
list 的表现
None 和 Nan 在 list 里的表现和等值性相同：
lst = [np.nan, None]
lst[0] == lst[0] # False
lst[0] == lst[1] # False
lst[1] == lst[1] # True
[np.nan, 1] == [None, 1] # False
dict 的表现
首先看在 key 值的表现：
print([i for i in {np.nan:1, None:1}]) # [nan, None]
{np.nan:1} == {np.nan:1} # True
我们可以看到，无论是 Nan 还是 None，都是可以作为 dict 的 key 值的。且互不相同（dict 不允许有相同 key 值）。
再看看 value 值：
dic = {'a':np.nan, 'b':None, 'c':np.nan, 'd':None}
print(dic['a'] == dic['b']) # False
print(dic['a'] == dic['c']) # False
print(dic['b'] == dic['d']) # True
与等值性、list里表现一致。
tuple 的表现
print((1, None) == (1, None)) # True
print((1, None) == (1, np.nan)) # False
print((1, np.nan) == (1, np.nan)) # True
第一个和第二个的表现都与 list 和 dict 表现一n'p致，但需要注意的是第三个情况，返回的也是True。
tuple 返回 True 的原因是因为，tuple 的比较是 is 而非 =
set 的表现
print({None, 1} == {None, 1}) # True
print({None, 1} == {np.nan, 1}) # False
print({np.nan, 1} == {np.nan, 1}) # True
可以看到 set 与 tuple 是类似的。与  list 和 dict 不同。
对上述内容进行总结：
s1 = pd.Series([1, np.nan]) # dtype:float64，其他如常
s2 = pd.Series([1, None]) # dtype:float64，None被替换为NaN
s3 = pd.Series(['a', np.nan]) # dtype:object，NaN不变
s4 = pd.Series(['a', None]) # dtype:object，None不变
print(s1, s2, s3, s4)
我们可以看到，在 s3 里，None 和 NaN 就开始出现彼此的转化了,是 Object 类型的 None 被替换成了 float 类型的 NaN。 这么设计可能是因为 None 在参与 numpy 的运算中效率远不如 Nan，因此做了这样的自动转化。
不过如果本来Series就只能用object类型容纳的话， Series 不会做这样的转化工作。
据 pandas 作者自己在论坛的回应，Nan 的本身就是 浮点型的 None，从而加快计算效率。
用表格来总结：
我们先直接用 == 来比对
pd.Series([np.nan,'a']) == pd.Series([np.nan,'a']) # False
pd.Series([None,'a']) == pd.Series([np.nan,'a']) # False
pd.Series([None,'a']) == pd.Series([None,'a']) # False
都是 False。
再试试 Series 自带的 equals ：
pd.Series([np.nan,'a']).equals(pd.Series([np.nan,'a'])) # True
pd.Series([np.nan,'a']).equals(pd.Series([None,'a'])) # True
pd.Series([None,'a']).equals(pd.Series([None,'a'])) # True
这次都是 True......
常见的函数
map 函数
s = pd.Series([None, NaN, 'a'])
0    None
1     NaN
2       a
dtype: object
s.map({None:1,'a':'a'})
0    1
1    1
2    a
dtype: object
s.map({np.nan:1,'a':'a'})
0    1
1    1
2    a
dtype: object
在这里，map 函数将 None 和 Nan 都替换为 1。无论指定哪一个，都会正常生效。
replace 函数？
s = pd.Series([None, np.NaN, 'a'])
0    None
1     NaN
2       a
dtype: object
s.replace([np.NaN],9)
0    9
1    9
2    a
dtype: object
s.replace([None],9)
0    9
1    9
2    a
dtype: object
可以看到 replace 函数与 map 函数类似，会彼此替换掉。
同样，我们先来看在 numpy 和 df 里的类型。
np.array([1, 0]).dtype #dtype('int64')
np.array([1, np.nan]).dtype # dtype('float64')
np.array([1, None]).dtype # dtype('O')
d = pd.DataFrame({'A':[1,1,1,1,2],'B':[None,np.NaN,'a','a','b'],'C':[np.nan,None,'a','a','b']})
d['B'] == d['C']  #前两个为False
可以看到 Nan 和 None 对 array 的影响完全不同。Nan 会使 int 类型变成 float，而 None 则会直接更改为 0。至于在 df 里，完全不同。
常见的函数
nansum
np.nansum([1,2,0]) # 3
np.nansum([1,2,np.nan]) # 3.0
np.nansum([1,2,None]) # TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'
Nan 与我们的预期一样，仅将数据类型由 int 变为了 float。
data = { 'row1' : [1,2,3,4], 'row2' : [None , 'b' , np.nan , 'd'] }
df = pd.DataFrame(data)
print(df.isnull()) # None和Nan都被识别为True
print(df.notnull()) # None和Nan都被识别为False
print(df.fillna(0)) # None和Nan都被填充为0
print(df.replace(np.nan, 1)) # None和Nan都被替换为1
print(df.replace(None, 1)) # 报错
可以看到，pd 里专业用来找 NULL 的可以识别2个；但是 replace 不能识别，使用时需要注意。
merge
a = pd.DataFrame({'A':[None,'a']})
b = pd.DataFrame({'A':[None,'a']})
c = pd.DataFrame({'A':[np.nan,'a']})
d = pd.DataFrame({'A':[np.nan,'a']})
a.merge(b,on='A', how = 'outer') # 能匹配到
c.merge(d,on='A', how = 'outer') # 能匹配到
a.merge(b,on='A', how = 'outer') # 能匹配到，到底展示 Nan 还是 None 看哪个在左边
在 merge 方法里，Nan 和 None 会被识别为同一个值。
聚合(Group by)
d = pd.DataFrame({'A':[1,1,1,1,2],'B':[None,np.nan,'a','a','b']})
d.groupby(['A','B']).apply(len)
None和Nan 都没有被处理
1 a  2
2 b  1
d.groupby(['B']).mean()
None 和 Nan 都没有被处理
这里需要注意一点：无论是 Nan 还是 None，在 mean() 里都不会被计算，但如果你将它们替换为了 0 ，就会拉低均值的下限了。具体要不要替换，视具体业务而定。
大部分时候我们要处理这两个值，主要都是因为 Nan 无法入库。这里我们在最后根据直接转化值为 0 或其他即可：
df.fillna(0) # 用于写入字段为 float 类型
df.fillna('其他') # 用于指定要求其他值的
也可以使用 isnull() 等函数进行查找更替，但要小心 replace 处理 NULL 的异常。
None 和 NAN 都会对常见的计算造成很大的困扰：
np.nan + 1 # nan
0 + 1 # 1
None + 1 # 报错
随然有很多计算方法，但大家还是很喜欢用简单的四则来直接运算，此时如果不转化 nan 和 None，就会酿出惨剧。
d = pd.DataFrame({'A':[0,0,3,4,5],'B':[None,np.nan,3,4,5]})
d['A'].mean() # 2,4
d['B'].mean() # 4.0
可以看到，0 并不等价于 Nan/None。
3.2 处理原则
我们可以遵循以下原则进行处理：
在刚读取到数据后，None 和 Nan 统一处理成 NaN，以便支持更多的函数。
如果要判断 Series，numpy.array 整体的等值性，用专门的 Series.equals,numpy.array 函数去处理，不要自己用==判断
如果要将数据导入数据库，将 NaN 替换成 None。
None 和 Nan 都是 python 的数据空值，None 更为特殊，Nan 则属于 numpy 产生。两者并不完全等价。
在大部分的函数里，None 和 Nan 都是被一并处理的，但在 replace 里不行。
在聚合函数（group by）里，Nan 和 None 都不会被计算。
在写入数据库时，Nan 会报错，而 None 不会。
数据清洗的处理原则：
在刚读取到数据后，None 和 Nan 统一处理成 NaN，以便支持更多的函数。