如何在熊猫DataFrame中计算一列中的NaN值？

您可以从非nan值的计数中减去总长度：

count_nan = len(df) - df.count()

您应该在数据上计时。与isnull解决方案相比，小型系列的速度提高了3倍。

使用isna()方法（或它的别名isnull()，也与较旧的熊猫版本<0.21.0兼容），然后求和以计算NaN值。对于一列：

>>> s = pd.Series([1,2,3, np.nan, np.nan])


>>> s.isna().sum()   # or s.isnull().sum() for older pandas versions
2

对于几个列，这也有效：

>>> df = pd.DataFrame({'a':[1,2,np.nan], 'b':[np.nan,1,np.nan]})


>>> df.isna().sum()
a    1
b    2
dtype: int64

从Pandas 0.14.1开始，我的建议这里在value_counts方法中使用关键字参数已经实现：

import pandas as pd
df = pd.DataFrame({'a':[1,2,np.nan], 'b':[np.nan,1,np.nan]})
for col in df:
print df[col].value_counts(dropna=False)


2     1
1     1
NaN    1
dtype: int64
NaN    2
1     1
dtype: int64

如果您使用的是Jupyter Notebook，那么…

 %%timeit
df.isnull().any().any()

或

 %timeit
df.isnull().values.sum()

或者，数据中是否有NaN，如果有，在哪里？

 df.isnull().any()

根据投票最多的答案，我们可以轻松定义一个函数，该函数为我们提供了一个数据框来预览缺失值和每列中缺失值的百分比：

def missing_values_table(df):
mis_val = df.isnull().sum()
mis_val_percent = 100 * df.isnull().sum() / len(df)
mis_val_table = pd.concat([mis_val, mis_val_percent], axis=1)
mis_val_table_ren_columns = mis_val_table.rename(
columns = {0 : 'Missing Values', 1 : '% of Total Values'})
mis_val_table_ren_columns = mis_val_table_ren_columns[
mis_val_table_ren_columns.iloc[:,1] != 0].sort_values(
'% of Total Values', ascending=False).round(1)
print ("Your selected dataframe has " + str(df.shape[1]) + " columns.\n"
"There are " + str(mis_val_table_ren_columns.shape[0]) +
" columns that have missing values.")
return mis_val_table_ren_columns

如果只是在熊猫列中计算nan值，这里是一个快速的方法

import pandas as pd
## df1 as an example data frame
## col1 name of column for which you want to calculate the nan values
sum(pd.isnull(df1['col1']))

在我的代码中使用了@sus hmit提出的解决方案。

同样的一个可能的变体也可以是

colNullCnt = []
for z in range(len(df1.cols)):
colNullCnt.append([df1.cols[z], sum(pd.isnull(trainPd[df1.cols[z]]))])

这样做的好处是它返回df中每个列的结果。

您可以使用value_counts方法并打印np.nan值

s.value_counts(dropna = False)[np.nan]

根据给出的答案和一些改进，这是我的方法

def PercentageMissin(Dataset):
"""this function will return the percentage of missing values in a dataset """
if isinstance(Dataset,pd.DataFrame):
adict={} #a dictionary conatin keys columns names and values percentage of missin value in the columns
for col in Dataset.columns:
adict[col]=(np.count_nonzero(Dataset[col].isnull())*100)/len(Dataset[col])
return pd.DataFrame(adict,index=['% of missing'],columns=adict.keys())
else:
raise TypeError("can only be used with panda dataframe")

df1.isnull().sum()

这会起作用的。

假设df是一个熊猫数据帧。

然后，

df.isnull().sum(axis = 0)

这将给出每列中NaN值的数量。

如果您需要，每行中的NaN值，

df.isnull().sum(axis = 1)

以下是按列计算Null值的代码：

df.isna().sum()

https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.count.html#pandas.Series.count

pandas.Series.count
Series.count(level=None)[source]

返回序列中非NA/null观测值的个数

import pandas as pd
import numpy as np


# example DataFrame
df = pd.DataFrame({'a':[1,2,np.nan], 'b':[np.nan,1,np.nan]})


# count the NaNs in a column
num_nan_a = df.loc[ (pd.isna(df['a'])) , 'a' ].shape[0]
num_nan_b = df.loc[ (pd.isna(df['b'])) , 'b' ].shape[0]


# summarize the num_nan_b
print(df)
print(' ')
print(f"There are {num_nan_a} NaNs in column a")
print(f"There are {num_nan_b} NaNs in column b")

作为输出：

     a    b
0  1.0  NaN
1  2.0  1.0
2  NaN  NaN


There are 1 NaNs in column a
There are 2 NaNs in column b

如果您需要获取Groupby拉出的不同组中的非NA（非无）和NA（无）计数：

gdf = df.groupby(['ColumnToGroupBy'])


def countna(x):
return (x.isna()).sum()


gdf.agg(['count', countna, 'size'])

这将返回非NA计数、NA和每个组的条目总数。

2017年7月有一篇很好的Dzone文章，详细介绍了总结NaN值的各种方法。查看这里。

我引用的文章通过以下方式提供了额外的价值：（1）展示了一种计算和显示每一列的NaN计数的方法，以便人们可以轻松地决定是否丢弃这些列；（2）展示了一种选择具有NaN的特定行的方法，以便可以选择性地丢弃或估算它们。

这里有一个简单的例子来演示这种方法的实用性——只有几列，也许它的有用性并不明显，但我发现它对更大的数据帧有帮助。

import pandas as pd
import numpy as np


# example DataFrame
df = pd.DataFrame({'a':[1,2,np.nan], 'b':[np.nan,1,np.nan]})


# Check whether there are null values in columns
null_columns = df.columns[df.isnull().any()]
print(df[null_columns].isnull().sum())


# One can follow along further per the cited article

import numpy as np
import pandas as pd


raw_data = {'first_name': ['Jason', np.nan, 'Tina', 'Jake', 'Amy'],
'last_name': ['Miller', np.nan, np.nan, 'Milner', 'Cooze'],
'age': [22, np.nan, 23, 24, 25],
'sex': ['m', np.nan, 'f', 'm', 'f'],
'Test1_Score': [4, np.nan, 0, 0, 0],
'Test2_Score': [25, np.nan, np.nan, 0, 0]}
results = pd.DataFrame(raw_data, columns = ['first_name', 'last_name', 'age', 'sex', 'Test1_Score', 'Test2_Score'])

results
'''
first_name last_name   age  sex  Test1_Score  Test2_Score
0      Jason    Miller  22.0    m          4.0         25.0
1        NaN       NaN   NaN  NaN          NaN          NaN
2       Tina       NaN  23.0    f          0.0          NaN
3       Jake    Milner  24.0    m          0.0          0.0
4        Amy     Cooze  25.0    f          0.0          0.0
'''

您可以使用以下函数，它将在Dataframe中为您提供输出

• 零值
• 缺失值
• 占总价值的百分比
• 总零缺失值
• %总零缺失值
• 数据类型

只需复制并粘贴以下函数并通过传递您的熊猫数据框调用它

def missing_zero_values_table(df):
zero_val = (df == 0.00).astype(int).sum(axis=0)
mis_val = df.isnull().sum()
mis_val_percent = 100 * df.isnull().sum() / len(df)
mz_table = pd.concat([zero_val, mis_val, mis_val_percent], axis=1)
mz_table = mz_table.rename(
columns = {0 : 'Zero Values', 1 : 'Missing Values', 2 : '% of Total Values'})
mz_table['Total Zero Missing Values'] = mz_table['Zero Values'] + mz_table['Missing Values']
mz_table['% Total Zero Missing Values'] = 100 * mz_table['Total Zero Missing Values'] / len(df)
mz_table['Data Type'] = df.dtypes
mz_table = mz_table[
mz_table.iloc[:,1] != 0].sort_values(
'% of Total Values', ascending=False).round(1)
print ("Your selected dataframe has " + str(df.shape[1]) + " columns and " + str(df.shape[0]) + " Rows.\n"
"There are " + str(mz_table.shape[0]) +
" columns that have missing values.")
#         mz_table.to_excel('D:/sampledata/missing_and_zero_values.xlsx', freeze_panes=(1,0), index = False)
return mz_table


missing_zero_values_table(results)

产出

Your selected dataframe has 6 columns and 5 Rows.
There are 6 columns that have missing values.


Zero Values  Missing Values  % of Total Values  Total Zero Missing Values  % Total Zero Missing Values Data Type
last_name              0               2               40.0                          2                         40.0    object
Test2_Score            2               2               40.0                          4                         80.0   float64
first_name             0               1               20.0                          1                         20.0    object
age                    0               1               20.0                          1                         20.0   float64
sex                    0               1               20.0                          1                         20.0    object
Test1_Score            3               1               20.0                          4                         80.0   float64

如果你想保持简单，那么你可以使用以下函数来获取%中的缺失值

def missing(dff):
print (round((dff.isnull().sum() * 100/ len(dff)),2).sort_values(ascending=False))




missing(results)
'''
Test2_Score    40.0
last_name      40.0
Test1_Score    20.0
sex            20.0
age            20.0
first_name     20.0
dtype: float64
'''

假设你想在一个名为评论的数据框中获取称为价格的列（系列）中缺失值（NaN）的数量

#import the dataframe
import pandas as pd


reviews = pd.read_csv("../input/wine-reviews/winemag-data-130k-v2.csv", index_col=0)

要获取缺失的值，以n_missing_prices作为变量，只需

n_missing_prices = sum(reviews.price.isnull())
print(n_missing_prices)

sum是这里的关键方法，在我意识到sum是在这种情况下使用的正确方法之前，我尝试使用计数

另一个尚未建议的简单选项，只是计算NaN，将添加形状以返回具有NaN的行数。

df[df['col_name'].isnull()]['col_name'].shape

要计算零：

df[df == 0].count(axis=0)

计算NaN：

df.isnull().sum()

或

df.isna().sum()

df.isnull().sum() 将给出缺失值的逐列总和。

如果您想知道特定列中缺失值的总和，则可以使用以下代码：df.column.isnull().sum()

请使用下面的特定列计数

dataframe.columnName.isnull().sum()

对于您的任务，您可以使用pandas.DataFrame.dropna（https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.dropna.html）：

import pandas as pd
import numpy as np


df = pd.DataFrame({'a': [1, 2, 3, 4, np.nan],
'b': [1, 2, np.nan, 4, np.nan],
'c': [np.nan, 2, np.nan, 4, np.nan]})
df = df.dropna(axis='columns', thresh=3)


print(df)

您可以通过该参数为DataFrame中的所有列声明NaN值的最大计数。

代码输出：

     a    b
0  1.0  1.0
1  2.0  2.0
2  3.0  NaN
3  4.0  4.0
4  NaN  NaN

下面将按降序打印所有南列。

df.isnull().sum().sort_values(ascending = False)

或

下面将按降序打印前15栏。

df.isnull().sum().sort_values(ascending = False).head(15)

希望这能有所帮助，

import pandas as pd
import numpy as np
df = pd.DataFrame({'a':[1,2,np.nan], 'b':[np.nan,1,np.nan],'c':[np.nan,2,np.nan], 'd':[np.nan,np.nan,np.nan]})

df.isnull().sum()/len(df) * 100

Thres = 40
(df.isnull().sum()/len(df) * 100 ) < Thres

对于第一部件计数NaN我们有多种方式。

方法1count，由于count将忽略与size不同的NaN

print(len(df) - df.count())

方法2isnull/isna链带sum

print(df.isnull().sum())
#print(df.isna().sum())

方法3describe/info：注意这将输出'Notnull'值计数

print(df.describe())
#print(df.info())

方法numpy

print(np.count_nonzero(np.isnan(df.values),axis=0))

对于问题的第二部分，如果我们想将列按阈值删除，我们可以尝试使用dropna

阈值，可选要求许多非NA值。

Thresh = n # no null value require, you can also get the by int(x% * len(df))
df = df.dropna(thresh = Thresh, axis = 1)

df.isnull().sum()
//type: <class 'pandas.core.series.Series'>

或

df.column_name.isnull().sum()
//type: <type 'numpy.int64'>

我使用这个循环来计算每列的缺失值：

# check missing values
import numpy as np, pandas as pd
for col in df:
print(col +': '+ np.str(df[col].isna().sum()))

我写了一个简短的函数（Python 3）来生成. info作为熊猫数据框，然后可以写入Excel：

df1 = pd.DataFrame({'a':[1,2,np.nan], 'b':[np.nan,1,np.nan]})
def info_as_df (df):
null_counts = df.isna().sum()
info_df = pd.DataFrame(list(zip(null_counts.index,null_counts.values))\
, columns = ['Column', 'Nulls_Count'])
data_types = df.dtypes
info_df['Dtype'] = data_types.values
return info_df
print(df1.info())
print(info_as_df(df1))

其中给出：

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 3 entries, 0 to 2
Data columns (total 2 columns):
#   Column  Non-Null Count  Dtype
---  ------  --------------  -----
0   a       2 non-null      float64
1   b       1 non-null      float64
dtypes: float64(2)
memory usage: 176.0 bytes
None
Column  Nulls_Count    Dtype
0      a            1  float64
1      b            2  float64

您可以使用df.iteritems（）遍历数据帧。在for循环中设置一个条件来计算每列的NaN值百分比，并删除那些包含超过设置阈值的NaN值的条件：

for col, val in df.iteritems():
if (df[col].isnull().sum() / len(val) * 100) > 30:
df.drop(columns=col, inplace=True)

您可以尝试：

In [1]: s = pd.DataFrame('a'=[1,2,5, np.nan, np.nan,3],'b'=[1,3, np.nan, np.nan,3,np.nan])


In [4]: s.isna().sum()
Out[4]: out = {'a'=2, 'b'=3} # the number of NaN values for each column

如果需要，总人数：

In [5]: s.isna().sum().sum()
Out[6]: out = 5  #the inline sum of Out[4]

另一种只是为了完整性的方法是使用np.count_nonzero和. isna（）：

np.count_nonzero(df.isna())


%timeit np.count_nonzero(df.isna())
512 ms ± 24.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

使用1000005行×16列数据框与顶部答案进行比较：

%timeit df.isna().sum()
492 ms ± 55.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)


%timeit df.isnull().sum(axis = 0)
478 ms ± 34.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)


%timeit count_nan = len(df) - df.count()
484 ms ± 47.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

数据：

raw_data = {'first_name': ['Jason', np.nan, 'Tina', 'Jake', 'Amy'],
'last_name': ['Miller', np.nan, np.nan, 'Milner', 'Cooze'],
'age': [22, np.nan, 23, 24, 25],
'sex': ['m', np.nan, 'f', 'm', 'f'],
'Test1_Score': [4, np.nan, 0, 0, 0],
'Test2_Score': [25, np.nan, np.nan, 0, 0]}
results = pd.DataFrame(raw_data, columns = ['first_name', 'last_name', 'age', 'sex', 'Test1_Score', 'Test2_Score'])


# big dataframe for %timeit
big_df = pd.DataFrame(np.random.randint(0, 100, size=(1000000, 10)), columns=list('ABCDEFGHIJ'))
df = pd.concat([big_df,results]) # 1000005 rows × 16 columns