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

460

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 .

user3799307
quelle

Antworten:

729

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
Joris
quelle
31
Und wenn Sie die Gesamtzahl der Nans im Ganzen wollen df, können Sie verwendendf.isnull().sum().sum()
RockJake28
2
Um Spalten zu erhalten, .sum(axis=0)ist dies das Standardverhalten. Und um Zeilensummen zu bekommen , .sum(axis=1).
smci
1
@ RockJake28 Ordf.isnull().values.sum()
cs95
3
df['column_name'].isna().sum()funktioniert auch, wenn sich jemand wundert.
Superdooperhero
93

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.

Elyase
quelle
4
In der Tat die beste Zeit dafür. Es wird von der Größe des Rahmens abhängen, den ich denke, bei einem größeren Rahmen (3000 Zeilen) ist die Verwendung isnullbereits zweimal schneller als dieser.
Joris
5
Ich habe es in beide Richtungen versucht, in einer Situation, in der ich die Länge der Gruppe für eine große Gruppe gezählt habe, wobei die Gruppengrößen normalerweise <4 waren und joris 'df.isnull (). Sum () mindestens 20x schneller war. Dies war mit 0.17.1.
Nathan Lloyd
Für mich sind beide unter 3 ms Durchschnitt für 70.000 Zeilen mit sehr wenigen Na's.
Josiah Yoder
89

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)
rAmAnA
quelle
46

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
Nikos Tavoularis
quelle
36

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
K.-Michael Aye
quelle
Die bisher beste Antwort ermöglicht es, auch andere Wertetypen zu zählen.
gaborous
19

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']))
Sushmit
quelle
2
sushmit, Dieser Weg ist nicht sehr schnell, wenn Sie mehrere Spalten haben. In diesem Fall müssten Sie jeden Spaltennamen kopieren und einfügen / eingeben und dann den Code erneut ausführen.
Amos Long
17

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()
Manoj Kumar
quelle
13

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)
Amar Kumar
quelle
10
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
'''
Suhas_Pote
quelle
10

So zählen Sie Nullen:

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

Um NaN zu zählen:

df.isnull().sum()

oder

df.isna().sum()
Pygirl
quelle
8

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

s.value_counts(dropna = False)[np.nan]
Itachi
quelle
Nett! Dieser ist am nützlichsten, wenn Sie sowohl NaNs als auch Nicht-NaNs zählen möchten. s.value_counts(dropna = False)
icemtel
8

Bitte verwenden Sie unten für bestimmte Spaltenanzahl

dataframe.columnName.isnull().sum()
Anurag Bhakuni
quelle
3
df1.isnull().sum()

Dies wird den Trick machen.

Naveen Bharadwaj
quelle
3

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

df.isna().sum()
Sanket
quelle
3

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
Durchschn
quelle
3

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
SlipperyD
quelle
2

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

K Pradeep Kumar Reddy
quelle
1

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")
Espoir Murhabazi
quelle
Ich bevorzugedf.apply(lambda x: x.value_counts(dropna=False)[np.nan]/x.size*100)
K.-Michael Aye
1

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.

Aysa
quelle
0

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.

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

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

John R.
quelle
-1

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
Anastasia Didan
quelle