Python 如何在DataFrame中计算列中的NaN值

我想在我的数据的每一列中找到

NaN

的数量，这样如果

NaN

少于某个阈值，我就可以删除该列。我看了一下，但找不到任何函数。对我来说太慢了，因为大多数值都是不同的，我只对

NaN

计数感兴趣。

您可以从非NaN值中减去总长度：

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

你应该根据你的数据来计时。对于小型系列，与

isnull

解决方案相比，速度提高了3倍。

您可以使用该方法（或者它的别名

isnull（）

，它也与较早版本的<0.21.0]兼容），然后求和以计算NaN值。对于一列：

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

In [4]: s.isna().sum()   # or s.isnull().sum() for older pandas versions
Out[4]: 2

对于多个列，它也可以工作：

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

In [6]: df.isna().sum()
Out[6]:
a    1
b    2
dtype: int64

---

从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笔记本，那么

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

或

或者，在数据中是否存在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']))

---

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

也可以使用相同的可能变化

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

---

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

您可以使用value\u 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")

---

这就可以了。

让我们假设

df

是一个数据帧

那么

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

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

如果需要，每行中的NaN值

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

---

以下是按列计算

Null

值的代码：

df.isna().sum()

返回序列中非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（非None）和NA（None）计数：

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

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

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

---

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

2017年7月有一篇nice 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

---

您可以使用以下函数，它将以数据帧的形式提供输出

• 零值
• 缺失值
• %总值
• 总零缺失值
• %总零缺失值
• 数据类型

只需复制并粘贴以下函数，并通过传递数据帧调用它

输出

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
'''

---

假设您希望在名为reviews的数据框架中获取名为price的列（系列）中缺少的值的数量（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_price作为变量，只需执行以下操作

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

---

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

另一个尚未建议的简单选项，仅计算NaN，将在形状中添加以返回包含NaN的行数

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

---

计数零：

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

df.isnull().sum()

要计数NaN:

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

df.isnull().sum()

或

df.isnull（）.sum（）

将给出缺失值的按列求和

---

如果您想知道特定列中缺失值的总和，那么以下代码将起作用：

df.column.isnull（）.sum（）

请使用下面的特定列计数

dataframe.columnName.isnull().sum()

---

对于您的任务，可以使用pandas.DataFrame.dropna（）：

使用thresh参数，可以为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

---

下面将按降序打印所有Nan列

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

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

或

下面将按降序打印前15列Nan

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

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]})

Thres=40
（df.isnull（）.sum（）/len（df）*100）

---

对于1st零件计数

NaN

我们有多种方法

方法1

count

，由于

count

将忽略与

size

不同的

NaN

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

方法2

isnull

/

isna

与

sum

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

方法3

描述

/

信息

：注意这将输出'notnull'值计数

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

方法来自

numpy

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

---

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

dropna

thresh（可选）需要许多非NA值

---

一种解决方案是找出空值行并将其转换为数据帧，然后检查新数据帧的长度-

nan_rows = df[df['column_name'].isnull()]
print(len(nan_rows))

df.isnull（）.sum（）
//类型：

或

df.column\u name.isnull（）.sum（）
//类型：

事实上，这是最好的时机。这将取决于帧的大小，我认为，对于更大的帧（3000行），使用

isnull

的速度已经是这一速度的两倍。我尝试了两种方法，一种是为一个巨大的groupby计算组的长度，而组的大小通常是我的，在70000行中，这两个平均值都低于3ms，只有很少的na，如果你想要tota的话

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

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

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

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

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

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

nan_rows = df[df['column_name'].isnull()]
print(len(nan_rows))

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

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