实现它作为一个班轮的一种方法是：

len([i for i in xx if i is None])
# or the count function
xx.count(None)

也可以使用numpy.count_nonzero：

np.count_nonzero(xx == None)

使用lambda函数，你可以创建一个类似list.count()的函数：

>>> counter = lambda x,y:len([i for i in x if i == y])
>>> counter(xx,None)
2

这不是一个lambda，但它创建了一个新的列表，只有None值，并计算该列表的长度。

import numpy as np
xx = np.array([2,3,4,None,np.nan,None])
print(len([elem for elem in xx if elem is None]))

如果你不需要它在numpy中，你可以使用列表计数方法

xx = [2,3,4,None,np.nan,None]
print(xx.count(None))

lambda只是一种用于创建函数的受限格式。它是“一行”并返回一个值。它不应该用于副作用。你使用counter += 1是一个副作用，所以不能在lambda中使用。
lambda标识None值，可与map一起使用：

In [27]: alist = [2,3,4,None,np.nan,None]                                                              
In [28]: list(map(lambda x: x is None, alist))                                                         
Out[28]: [False, False, False, True, False, True]

map返回一个iterable，它必须用list或sum扩展：

In [29]: sum(map(lambda x: x is None, alist))                                                          
Out[29]: 2

但正如其他人所示，列表count方法更简单。

In [43]: alist.count(None)                                                                             
Out[43]: 2
In [44]: alist.count(np.nan)                                                                           
Out[44]: 1

包含None的数组将是对象dtype。在这样的数组上迭代比在列表上迭代慢：

In [45]: arr = np.array(alist)                                                                         
In [46]: arr                                                                                           
Out[46]: array([2, 3, 4, None, nan, None], dtype=object)

数组没有count方法。测试np.nan也比较棘手。

In [47]: arr == None                                                                                   
Out[47]: array([False, False, False,  True, False,  True])
In [48]: arr == np.nan                                                                                 
Out[48]: array([False, False, False, False, False, False])

有一个np.isnan函数，但它只适用于float dtype数组。

In [51]: arr.astype(float)                                                                             
Out[51]: array([ 2.,  3.,  4., nan, nan, nan])
In [52]: np.isnan(arr.astype(float))                                                                   
Out[52]: array([False, False, False,  True,  True,  True])

第三种方法：

>>> nan_count, none_count = np.sum([i is np.nan for i in xx]), np.sum([i is None for i in xx])
>>> print(nan_count, none_count)
1, 2

我倾向于使用两行代码（每个计算一行），但这样也行。它的工作原理是为每个True值添加1，为每个False值添加0。
如果你真的想使用lambda，另一种方法是使用functools.reduce，它将迭代地执行求和。在这里，我们从值0开始，并为每个评估为true的元素添加1：

>>> functools.reduce(lambda x,y: x+(y is np.nan), xx, 0)
1
>>> functools.reduce(lambda x,y: x+(y is None), xx, 0)
2

l= len（list（filter（lambda x：x is None，xx）））
它将返回NaN值的数量。但是过滤器函数只对列表起作用。如果你想使用lambda，你可以使用这种方法。我更喜欢使用numpy函数（np.count_nonzero）