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

Ich habe Daten, in denen ich die Anzahl der Daten ermitteln möchte. NaNWenn diese unter einem bestimmten Schwellenwert liegen, werden diese Spalten gelöscht. Ich habe nachgesehen, konnte aber keine Funktion dafür finden. es gibt value_counts, aber es wäre langsam für mich, weil die meisten Werte unterschiedlich sind und ich NaNnur zählen möchte .

Sie können die isna()Methode verwenden (oder den Alias, isnull()der auch mit älteren Pandas-Versionen <0.21.0 kompatibel ist) und dann summieren, um die NaN-Werte zu zählen. 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

Sie können die Gesamtlänge von der Anzahl der Nicht-Nan-Werte abziehen :

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

Sie sollten es auf Ihren Daten zeitlich festlegen. Für kleine Serien wurde eine 3-fache Geschwindigkeit im Vergleich zur isnullLösung erzielt.

Nehmen wir an, es dfhandelt sich um einen Pandas DataFrame.

Dann,

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

Dies gibt die Anzahl der NaN-Werte in jeder Spalte an.

Wenn Sie brauchen, NaN-Werte in jeder Zeile,

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

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

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

Seit pandas 0.14.1 wurde mein Vorschlag, hier ein Schlüsselwortargument in der value_counts-Methode zu haben, 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

Wenn es nur darum geht, Nan-Werte in einer Pandas-Spalte zu zählen, 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']))

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

Im Folgenden werden alle Nan-Spalten in absteigender Reihenfolge gedruckt.

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

oder

Im Folgenden werden die ersten 15 Nanospalten in absteigender Reihenfolge gedruckt.

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

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 in Dataframe ausgeben können

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

Kopieren Sie einfach die folgende Funktion und fügen Sie sie ein. Rufen Sie sie auf, indem Sie Ihren Pandas-Datenrahmen übergeben

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

So zählen Sie Nullen:

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

Um NaN zu zählen:

df.isnull().sum()

oder

df.isna().sum()

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

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

Bitte verwenden Sie unten für bestimmte Spaltenanzahl

dataframe.columnName.isnull().sum()

df1.isnull().sum()

Dies wird den Trick machen.

Hier ist der Code zum Nullspaltenweisen Zählen von Werten:

df.isna().sum()

Es gibt einen schönen Dzone-Artikel vom Juli 2017, der verschiedene Möglichkeiten zur Zusammenfassung von NaN-Werten beschreibt. Schau es dir hier an .

Der Artikel, den ich zitiert habe, bietet zusätzlichen Wert durch: (1) Anzeigen einer Möglichkeit zum Zählen und Anzeigen von NaN-Zählungen für jede Spalte, damit man leicht entscheiden kann, ob diese Spalten verworfen werden sollen oder nicht, und (2) Demonstrieren einer Möglichkeit zum Auswählen dieser Zeilen in spezifisch, die NaNs haben, 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 seine Nützlichkeit vielleicht nicht offensichtlich, aber ich fand, dass er 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

Eine andere 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

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

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

Basierend auf der 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")

Für den Fall, dass Sie die Nicht-NA- (Nicht-Keine) und NA- (Keine) Zählungen für verschiedene Gruppen erhalten müssen, die von groupby herausgezogen wurden:

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

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

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

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

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

Dies hat den Vorteil, dass von nun an das Ergebnis für jede der Spalten in der df zurückgegeben wird.

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:

     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

Angenommen, Sie möchten die Anzahl der fehlenden Werte (NaN) in einer Spalte (Serie) ermitteln, die als Preis in einem Datenrahmen mit dem Namen "Bewertungen" 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 erhalten, gehen Sie einfach vor

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

sum ist die Schlüsselmethode hier, ich habe versucht, count zu verwenden, bevor mir klar wurde, dass sum die richtige Methode ist, um sie in diesem Kontext zu verwenden

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

Für Ihre Aufgabe können Sie pandas.DataFrame.dropna verwenden ( 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)

Mit dem Schwellenwertparameter können Sie die maximale Anzahl für NaN-Werte für alle Spalten in DataFrame deklarieren.

Code-Ausgaben:

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