Python 中 NaN 和 None 的详细比较

最新推荐文章于 2024-03-18 18:20:13 发布

I天辉I

最新推荐文章于 2024-03-18 18:20:13 发布

阅读量5.9k

点赞数 6

Pandas&Numpy 专栏收录该内容

97 篇文章 2 订阅

订阅专栏

python原生的None和pandas, numpy中的numpy.NaN尽管在功能上都是用来标示空缺数据。但它们的行为在很多场景下确有一些相当大的差异。由于不熟悉这些差异，曾经给我的工作带来过不少麻烦。　特此整理了一份详细的实验，比较None和NaN在不同场景下的差异。

实验的结果有些在意料之内，有些则让我大跌眼镜。希望读者看过此文后会None和NaN这对“小妖精”有更深的理解。

为了理解本文的内容,希望本文的读者需要对pandas的Series使用有一定的经验。

首先，导入所需的库

In[2]:

数据类型?

None是一个python特殊的数据类型，但是NaN却是用一个特殊的float

In[3]:

Python
 
         1 
       
        type 
        ( 
        None 
        )

Out[3]:

 
Python
 
         1 
       
        NoneType

In[4]:

Out[4]:

 
Python
 
         1 
       
        float

能作为dict的key?

In[5]:

Out[5]:

In[6]:

Out[6]:

In[7]:

Out[7]:

都可以，而且会被认为是不同的key

Series函数中的表现

Series.map

In[8]:

Out[8]:

In[9]:

Out[9]:

可以看到None和NaN都会替换成了1

In[10]:

Out[10]:

同样None和NaN都会替换成了1

In[11]:

Out[11]:

将None替换成1的要求被忽略了

In[12]:

Out[12]:

将NaN替换成1的要求被忽略了

总结: 用Series.map对None进行替换时,会“顺便”把NaN也一起替换掉；NaN也会顺便把None替换掉。

如果None和NaN分别定义了不同的映射数值，那么只有一个会生效。

Series.replace中的表现

In[13]:

Out[13]:

In[14]:

Out[14]:

In[15]:

Out[15]:

和Series.map的情况类似,指定了None的替换值后,NaN会被替换掉;反之亦然。

对函数的支持

numpy有不少函数可以自动处理NaN。

In[16]:

Out[16]:

但是None不能享受这些函数的便利，如果数据包含的None的话会报错

In[17]:

unsupported operand type(s) for +: ‘int’ and ‘NoneType’

pandas中也有不少函数支持NaN却不支持None。(毕竟pandas的底层是numpy)

In[18]:

Out[18]:

In[19]:

unorderable types: int() > NoneType()

对容器数据类型的影响

混入numpy.array的影响

如果数据中含有None,会导致整个array的类型变成object。

In[20]:

Out[20]:

 
Python
 
         1 
       
        dtype 
        ( 
        'O' 
        )

而np.NaN尽管会将原本用int类型就能保存的数据转型成float，但不会带来上面这个问题。

In[21]:

Out[21]:

 
Python
 
         1 
       
        dtype 
        ( 
        'float64' 
        )

混入Series的影响

下面的结果估计大家能猜到

In[22]:

Out[22]:

下面的这个就很意外的吧

In[23]:

Out[23]:

pandas将None自动替换成了NaN！

In[24]:

Out[24]:

却是Object类型的None被替换成了float类型的NaN。这么设计可能是因为None无法参与numpy的大多数计算，而pandas的底层又依赖于numpy，因此做了这样的自动转化。

不过如果本来Series就只能用object类型容纳的话， Series不会做这样的转化工作。

In[25]:

Out[25]:

如果Series里面都是None的话也不会做这样的转化

In[26]:

Out[26]:

其它的数据类型是bool时，也不会做这样的转化。

In[27]:

Out[27]:

等值性判断

单值的等值性比较

下面的实验中None和NaN的表现会作为后面的等值性判断的基准(后文称为基准)

In[28]:

Out[28]:

 
Python
 
         1 
       
        True

In[29]:

Out[29]:

 
Python
 
         1 
       
        False

In[30]:

Out[30]:

 
Python
 
         1 
       
        False

在tuple中的情况

这个不奇怪

In[31]:

Out[31]:

 
Python
 
         1 
       
        True

这个也不意外

In[32]:

Out[32]:

 
Python
 
         1 
       
        False

但是下面这个实验NaN的表现和基准不一致

In[33]:

Out[33]:

 
Python
 
         1 
       
        True

在numpy.array中的情况

In[34]:

Out[34]:

In[35]:

Out[35]:

In[36]:

Out[36]:

和基准的表现一致。

但是大部分情况我们希望上面例子中，我们希望左右两边的array被判定成一致。这时可以用numpy.testing.assert_equal函数来处理。注意这个函数的表现同assert，不会返回True, False，而是无反应或者raise Exception

In[37]:

Python
 
   
 
 
  
         1 
       
 
        np 
        . 
        testing 
        . 
        assert_equal 
        ( 
        np 
        . 
        array 
        ( 
        [ 
        1 
        , 
        NaN 
        ] 
        ) 
        , 
          
        np 
        . 
        array 
        ( 
        [ 
        1 
        , 
        NaN 
        ] 
        ) 
        ) 
       
 
 

它也可以处理两边都是None的情况

In[38]:

 
Python
 
         1 
       
        np 
        . 
        testing 
        . 
        assert_equal 
        ( 
        np 
        . 
        array 
        ( 
        [ 
        1 
        , 
        None 
        ] 
        ) 
        , 
          
        np 
        . 
        array 
        ( 
        [ 
        1 
        , 
        None 
        ] 
        ) 
        )

但是一边是None，一边是NaN时会被认为两边不一致, 导致AssertionError

In[39]:

Python
 
   
 
 
  
         1 
       

         2 
       

         3 
       

         4 
       
 
        try 
        : 
       
 
             
        np 
        . 
        testing 
        . 
        assert_equal 
        ( 
        np 
        . 
        array 
        ( 
        [ 
        1 
        , 
        NaN 
        ] 
        ) 
        , 
          
        np 
        . 
        array 
        ( 
        [ 
        1 
        , 
        None 
        ] 
        ) 
        ) 
       
 
        except 
          
        Exception 
          
        as 
          
        e 
        : 
       
 
             
        print 
        ( 
        type 
        ( 
        e 
        ) 
        , 
        e 
        ) 
       
 
 

 
Python
 
         1 
       
         2 
       
         3 
       
         4 
       
         5 
       
         6 
       
        & 
        lt 
        ; 
        class 
          
        'assertionerror' 
        = 
        "" 
        & 
        gt 
        ; 
          
        Arrays  
        are  
        not 
          
        equal 
       
        ( 
        mismatch 
          
        50.0 
        % 
        ) 
       
        x 
        : 
          
        array 
        ( 
        [ 
           
        1. 
        , 
           
        nan 
        ] 
        ) 
       
        y 
        : 
          
        array 
        ( 
        [ 
        1 
        , 
          
        None 
        ] 
        , 
          
        dtype 
        = 
        object 
        )

在Series中的情况

下面两个实验中的表现和基准一致

In[40]:

Out[40]:

In[41]:

Out[41]:

但是None和基准的表现不一致。

In[42]:

Out[42]:

和array类似，Series也有专门的函数equals用于判断两边的Series是否整体看相等

In[43]:

Out[43]:

 
Python
 
         1 
       
        True

In[44]:

Out[44]:

 
Python
 
         1 
       
        True

In[45]:

Out[45]:

 
Python
 
         1 
       
        True

比numpy.testing.assert_equals更智能些，三种情况下都能恰当的处理

在DataFrame merge中的表现

两边的None会被判为相同

In[46]:

Out[46]:

	A
0	None
1	a

两边的NaN会被判为相同

In[47]:

Out[47]:

	A
0	NaN
1	a

无论两边都是None,都是NaN，还是都有,相关的列都会被正确的匹配。注意一边是None,一边是NaN的时候。会以左侧的结果为准。

In[48]:

Out[48]:

	A
0	None
1	a

In[49]:

Out[49]:

	A
0	NaN
1	a

注意

这和空值在postgresql等sql数据库中的表现不一样，在数据库中， join时两边的空值会被判定为不同的数值

在groupby中的表现

In[50]:

Out[50]:

可以看到(1, NaN)对应的组直接被忽略了

In[51]:

Out[51]:

(1,None)的组也被直接忽略了

In[52]:

Out[52]:

那么上面这个结果应该没啥意外的

总结

DataFrame.groupby会忽略分组列中含有None或者NaN的记录

支持写入数据库?

往数据库中写入时NaN不可处理，需转换成None,否则会报错。这个这里就不演示了。

相信作为pandas老司机，至少能想出两种替换方法。

In[53]:

Out[53]:

方案１

In[54]:

Out[54]:

方案２

In[55]:

Out[55]:

然而这么就觉得完事大吉的话就图样图森破了，看下面的例子

In[56]:

Out[56]:

In[57]:

Out[57]:

In[58]:

Out[58]:

当其他数据是int或float时,Series又一声不吭的自动把None替换成了NaN。

这时候可以使用第三种方法处理

In[59]:

Out[59]:

where语句会遍历s中所有的元素，逐一检查条件表达式，如果成立，从原来的s取元素；否则用None填充。这回没有自动替换成NaN

None vs NaN要点总结

在pandas中，如果其他的数据都是数值类型， pandas会把None自动替换成NaN, 甚至能将s[s.isnull()]= None,和s.replace(NaN, None)操作的效果无效化。这时需要用where函数才能进行替换。
None能够直接被导入数据库作为空值处理，包含NaN的数据导入时会报错。
numpy和pandas的很多函数能处理NaN，但是如果遇到None就会报错。
None和NaN都不能被pandas的groupby函数处理，包含None或者NaN的组都会被忽略。

等值性比较的总结:（True表示被判定为相等）

	None对None	NaN对NaN	None对NaN
单值	True	False	False
tuple(整体)	True	True	False
np.array(逐个)	True	False	False
Series(逐个)	False	False	False
assert_equals	True	True	False
Series.equals	True	True	True
merge	True	True	True

由于等值性比较方面，None和NaN在各场景下表现不太一致，相对来说None表现的更稳定。

为了不给自己惹不必要的麻烦和额外的记忆负担。实践中，建议遵循以下三个原则即可

在用pandas和numpy处理数据阶段将None,NaN统一处理成NaN,以便支持更多的函数。
如果要判断Series,numpy.array整体的等值性，用专门的Series.equals,numpy.array函数去处理，不要自己用==判断 *
如果要将数据导入数据库，将NaN替换成None

I天辉I

关注

6
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
Python 中 NaN 和 None 的详细比较

python原生的None和pandas, numpy中的numpy.NaN尽管在功能上都是用来标示空缺数据。但它们的行为在很多场景下确有一些相当大的差异。由于不熟悉这些差异，曾经给我的工作带来过不少麻烦。　特此整理了一份详细的实验，比较None和NaN在不同场景下的差异。实验的结果有些在意料之内，有些则让我大跌眼镜。希望读者看过此文后会None和NaN这对“小妖精”有更深的理解。
复制链接

扫一扫