web-dev-qa-db-de.com

So zählen Sie die NaN-Werte in einer Spalte in Pandas DataFrame

Ich habe Daten, in denen ich die Nummer von NaN finden möchte, damit ich diese Spalten löschen kann, wenn sie unter einem bestimmten Schwellenwert liegt. Ich sah nach, konnte aber keine Funktion dafür finden. Es gibt value_counts , aber es wäre langsam für mich, weil die meisten Werte verschieden sind und ich nur die Anzahl von NaN zählen möchte.

pythonpandasdataframe
268
user3799307

Sie können die Methode isna() verwenden (oder deren Alias ​​isnull(), die auch mit älteren Pandas-Versionen <0.21.0 kompatibel ist) und dann die NaN-Werte summieren. Für eine Spalte:

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

Für mehrere Spalten funktioniert es auch:

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

Sie können die Gesamtlänge von count von Nicht-Nanowerten subtrahieren:

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

Du solltest es mal auf deine Daten einstellen. Für kleine Serien gab es eine dreifache Beschleunigung im Vergleich zur isnull-Lösung.

64
elyase

Nehmen wir an, df ist ein Pandas-DataFrame

Dann, 

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

Dies gibt eine Anzahl von NaN-Werten in jeder Spalte an. 

Wenn Sie brauchen, NaN-Werte in jeder Zeile, 

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

Basierend auf der meist gewählten Antwort können wir leicht eine Funktion definieren, die uns einen Datenrahmen gibt, um eine Vorschau der fehlenden Werte und des Prozentsatzes der fehlenden Werte in jeder Spalte anzuzeigen:

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

Seit Pandas 0.14.1 wurde mein Vorschlag hier ein Keyword-Argument in der value_counts-Methode implementiert:

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

wenn man nur Nan-Werte in einer Pandasäule zählt, ist dies ein schneller Weg

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

wenn Sie Jupyter Notebook verwenden, wie wäre es mit ....

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

oder

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

oder gibt es irgendwo NaNs in den Daten, wenn ja, wo?

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

Sie können die value_counts-Methode verwenden und Werte von np.nan drucken

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

das wird funktionieren!

4
Nikhila Munipalli

Nullen zählen:

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

m NaN zu zählen:

df.isnull().sum()

oder

df.isna().sum()
3
Pygirl

Eine weitere einfache Option, die noch nicht vorgeschlagen wurde, um nur NaNs zu zählen, wäre das Hinzufügen der Form, um die Anzahl der Zeilen mit NaN zurückzugeben.

df[df['col_name'].isnull()]['col_name'].shape
2
SlipperyD
df1.isnull().sum()

Das wird den Trick tun.

2
Naveen Bharadwaj

Es gibt einen Artikel von Nice Dzone aus Juli 2017, in dem verschiedene Arten der Zusammenfassung von NaN-Werten beschrieben werden. Checke es aus hier .

Der Artikel, den ich zitiert habe, bietet einen zusätzlichen Wert, indem er (1) einen Weg zeigt, NaN-Zählungen für jede Spalte zu zählen und anzuzeigen, so dass man leicht entscheiden kann, ob diese Spalten verworfen werden sollen, und (2) einen Weg gezeigt werden, diese Zeilen auszuwählen spezifisch, die NaNs aufweisen, so dass sie selektiv verworfen oder unterstellt werden können.

Hier ist ein kurzes Beispiel, um die Nützlichkeit des Ansatzes zu demonstrieren - mit nur wenigen Spalten ist die Nützlichkeit vielleicht nicht offensichtlich, aber ich finde, dass dies für größere Datenrahmen hilfreich ist.

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

Hier ist der Code für das Zählen von Null-Werten in Spaltenweise:

df.isna().sum()
1
Sanket

basierend auf der gegebenen Antwort und einigen Verbesserungen ist dies mein Ansatz 

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

Für den Fall, dass Sie die Anzahl der Nicht-NA (Nicht-Keine) und NA (Keine) über verschiedene Gruppen hinweg von der Gruppe entfernen lassen müssen:

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

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

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

Dies gibt die Anzahl der Nicht-NA- und NA-Einträge sowie die Gesamtzahl der Einträge pro Gruppe zurück.

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

Sie können die folgende Funktion verwenden, mit der Sie Daten in Dataframe ausgeben können

  • Nullwerte
  • Fehlende Werte
  • % der Gesamtwerte
  • Total Zero Missing Values
  • % Total Zero Missing Values
  • Datentyp

Kopiere und füge einfach die folgende Funktion ein und rufe sie auf, indem du deinen Pandas Dataframe übergibst 

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)

Ausgabe 

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

Wenn Sie es einfach halten möchten, können Sie die folgende Funktion verwenden, um fehlende Werte in% zu erhalten.

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

Angenommen, Sie möchten die Anzahl der fehlenden Werte (NaN) in einer Spalte (Serie) abrufen, die als Preis in einem Datenrahmen mit der Bezeichnung Überprüfungen bezeichnet wird

#import the dataframe
import pandas as pd

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

Um die fehlenden Werte mit n_missing_prices als Variable zu ermitteln, führen Sie einfach folgende Schritte aus

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

sum ist hier die Schlüsselmethode. Ich habe versucht, count zu verwenden, bevor mir klar wurde, dass sum in diesem Zusammenhang die richtige Methode ist

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")

Gibt als Ausgabe aus:

     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

Verwendet die von @sushmit vorgeschlagene Lösung in meinem Code. 

Eine mögliche Variation davon kann auch sein

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

Der Vorteil davon ist, dass das Ergebnis von nun an für jede der Spalten im df zurückgegeben wird.

0
vsdaking

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

pandas.Series.count Series.count (level = None) [source] Gibt die Anzahl der Nicht-NA/Null-Beobachtungen in der Serie zurück

0
sivi

df.isnull (). sum () gibt die spaltenweise Summe der fehlenden Werte an.

Wenn Sie die Summe der fehlenden Werte in einer bestimmten Spalte ermitteln möchten, funktioniert folgender Code: df.column.isnull (). Sum ()

0
Pradeepkumar Reddy