web-dev-qa-db-fra.com

Comment compter les valeurs de NaN dans une colonne de pandas DataFrame

J'ai des données, dans lesquelles je veux trouver le nombre de NaN, de sorte que s'il est inférieur à un seuil, je supprime ces colonnes. J'ai regardé, mais je n'ai pas trouvé de fonction pour cela. il y a value_counts , mais ce serait lent pour moi, car la plupart des valeurs sont distinctes et je ne compte que NaN.

pythonpandasdataframe
268
user3799307

Vous pouvez utiliser la méthode isna() (ou son alias isnull() qui est également compatible avec les anciennes versions de pandas <0.21.0), puis additionner pour compter les valeurs de NaN. Pour une colonne:

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

Pour plusieurs colonnes, cela fonctionne aussi:

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
501
joris

Vous pouvez soustraire la longueur totale du nombre de valeurs non-nan:

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

Vous devriez le chronométrer sur vos données. Pour les petites séries, la vitesse est 3 fois supérieure à celle de la solution isnull.

64
elyase

Supposons que df est un pandas DataFrame

Ensuite, 

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

Cela donnera le nombre de valeurs NaN dans chaque colonne. 

Si vous avez besoin, les valeurs NaN dans chaque ligne, 

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

En fonction de la réponse la plus votée, nous pouvons facilement définir une fonction qui nous donne un cadre de données pour prévisualiser les valeurs manquantes et le% de valeurs manquantes dans chaque colonne:

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
31
Nikos Tavoularis

Depuis pandas 0.14.1, ma suggestion ici d'avoir un argument de mot clé dans la méthode value_counts a été implémentée:

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
29
K.-Michael Aye

si sa juste compter nan valeurs dans une colonne de pandas voici un moyen rapide

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']))
15
sushmit

si vous utilisez Jupyter Notebook, que diriez-vous de ....

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

ou

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

ou, y a-t-il des NaN dans les données, si oui, où?

 df.isnull().any()
15
Manoj Kumar

Vous pouvez utiliser la méthode value_counts et imprimer les valeurs de np.nan.

s.value_counts(dropna = False)[np.nan]
5
Itachi
dataset.isnull().sum()

ça va marcher!

4
Nikhila Munipalli

Pour compter les zéros:

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

Compter NaN:

df.isnull().sum()

ou

df.isna().sum()
3
Pygirl
df1.isnull().sum()

Ça fera l'affaire.

2
Naveen Bharadwaj

Il y a un article de Nice Dzone paru en juillet 2017 qui détaille diverses manières de résumer les valeurs de NaN. Allez voir ici .

L'article que j'ai cité offre une valeur supplémentaire: (1) en montrant le moyen de compter et d'afficher le nombre de NaN pour chaque colonne, de sorte que l'on puisse facilement décider de ne pas mettre ces colonnes à l'écart et spécifiques qui ont des NaN afin qu’ils puissent être sélectivement écartés ou imputés.

Voici un exemple rapide pour démontrer l’utilité de l’approche - avec seulement quelques colonnes, son utilité n’est peut-être pas évidente, mais j’ai trouvé qu’elle était utile pour les plus grandes trames de données.

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
2
avg

Une autre option simple, non encore suggérée, consistant à compter uniquement les NaN, serait d’ajouter dans la forme le nombre de lignes contenant NaN.

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

Voici le code permettant de compter les valeurs Null en fonction de la colonne:

df.isna().sum()
1
Sanket

basé sur la réponse qui a été donnée et quelques améliorations c'est mon approche 

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")
1
Espoir Murhabazi

Si vous devez obtenir les comptes non-NA (non-None) et NA (None) de différents groupes, sortis par groupe, par

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

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

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

Ceci renvoie les nombres de non-NA, NA et le nombre total d'entrées par groupe.

1
aysa
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

Vous pouvez utiliser la fonction suivante, qui vous donnera une sortie dans Dataframe

  • Zéro Valeurs
  • Valeurs manquantes
  • % du total des valeurs
  • Total zéro valeurs manquantes
  • % Total zéro valeurs manquantes
  • Type de données

Copiez et collez la fonction suivante et appelez-la en passant votre pandas 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)

Sortie 

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

Si vous voulez garder les choses simples, vous pouvez utiliser la fonction suivante pour obtenir les valeurs manquantes en%

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
1
Suhas_Pote

Supposons que vous souhaitiez obtenir le nombre de valeurs manquantes (NaN) dans une colonne (série) appelée prix dans un cadre de données appelé revues

#import the dataframe
import pandas as pd

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

Pour obtenir les valeurs manquantes, avec n_missing_prices en tant que variable, il suffit de faire

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

somme est la méthode clé ici, essayait d'utiliser le compte avant que je réalise que somme est la bonne méthode à utiliser dans ce contexte

0
John R
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")

Donne en sortie:

     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
0
Arjaan Buijk

Utiliser la solution proposée par @sushmit dans mon code. 

Une variation possible de la même chose peut aussi être

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

L'avantage de ceci est qu'il renvoie désormais le résultat pour chacune des colonnes du df.

0
vsdaking

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

pandas.Series.count Series.count (niveau = Aucun) [source] Renvoie le nombre d'observations non-NA/nul dans la série.

0
sivi

df.isnull (). sum () donnera la somme par colonne des valeurs manquantes.

Si vous voulez connaître la somme des valeurs manquantes dans une colonne particulière, le code suivant fonctionnera df.column.isnull (). Sum ()

0
Pradeepkumar Reddy