Jak policzyć wartości NaN w kolumnie w pandach DataFrame

459

Mam dane, w których chcę znaleźć liczbę NaN, więc jeśli jest mniejsza niż jakiś próg, upuszczę te kolumny. Spojrzałem, ale nie byłem w stanie znaleźć dla tego żadnej funkcji. istnieje value_counts, ale byłoby to dla mnie powolne, ponieważ większość wartości jest odrębna i chcę NaNtylko liczyć .

użytkownik3799307
źródło

Odpowiedzi:

727

Możesz użyć isna()metody (lub jej aliasu, isnull()który jest również zgodny ze starszymi wersjami pand <0.21.0), a następnie zsumować, aby policzyć wartości NaN. Dla jednej kolumny:

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

W przypadku kilku kolumn działa również:

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
źródło
31
A jeśli chcesz mieć całkowitą liczbę nansów w całości df, możesz użyćdf.isnull().sum().sum()
RockJake28
2
Aby uzyskać kolumny, .sum(axis=0)co jest domyślnym zachowaniem. I dostać rowsums, .sum(axis=1).
smci
1
@ RockJake28 Ordf.isnull().values.sum()
cs95
3
df['column_name'].isna().sum()działa również, jeśli ktoś się zastanawia.
Superdooperhero
93

Możesz odjąć całkowitą długość od liczby wartości innych niż nan:

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

Powinieneś zmierzyć czas na swoich danych. Dla małych serii uzyskał 3-krotne przyspieszenie w porównaniu z isnullrozwiązaniem.

elyase
źródło
4
Rzeczywiście, najlepszy czas. Myślę, że będzie to zależeć od wielkości ramki, przy większej ramce (3000 rzędów) użycie isnulljest już dwa razy szybsze.
joris
5
Próbowałem tego na dwa sposoby w sytuacji, gdy liczyłem długość grupy dla dużej grupy, w której rozmiary grup były zwykle <4, a joris 'df.isnull (). Sum () był co najmniej 20 razy szybszy. Tak było z 0.17.1.
Nathan Lloyd,
Dla mnie oba są poniżej 3 ms dla 70 000 wierszy z bardzo małą liczbą na.
Josiah Yoder
89

Załóżmy, że dfjest to panda DataFrame.

Następnie,

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

To da liczbę wartości NaN w każdej kolumnie.

Jeśli potrzebujesz, wartości NaN w każdym wierszu,

df.isnull().sum(axis = 1)
RAMMA
źródło
46

W oparciu o najczęściej głosowaną odpowiedź możemy łatwo zdefiniować funkcję, która daje nam ramkę danych do podglądu brakujących wartości i% brakujących wartości w każdej kolumnie:

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
źródło
36

Od pand 0.14.1 moja sugestia tutaj mieć kluczowego argumentu w metodzie value_counts został wykonany:

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
źródło
Najlepsza jak dotąd odpowiedź, pozwala także liczyć inne typy wartości.
nudny
19

jeśli po prostu zlicza wartości nan w kolumnie pand, tutaj jest szybki sposób

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
źródło
2
sushmit, Ten sposób nie jest bardzo szybki, jeśli masz wiele kolumn. W takim przypadku musisz skopiować i wkleić / wpisać nazwę każdej kolumny, a następnie ponownie uruchomić kod.
Amos Long,
17

jeśli używasz Notatnika Jupyter, co powiesz na ...

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

lub

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

lub czy w danych jest gdziekolwiek NaN, jeśli tak, gdzie?

 df.isnull().any()
Manoj Kumar
źródło
13

Poniżej wydrukowane zostaną wszystkie kolumny Nan w kolejności malejącej.

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

lub

Poniżej wydrukowanych zostanie 15 pierwszych kolumn Nan w kolejności malejącej.

df.isnull().sum().sort_values(ascending = False).head(15)
Amar Kumar
źródło
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
'''

Możesz użyć następującej funkcji, która da ci wyjście w ramce danych

  • Zero wartości
  • Brakujące wartości
  • % wartości ogółem
  • Całkowite zero brakujących wartości
  • % Całkowitych brakujących wartości zero
  • Typ danych

Po prostu skopiuj i wklej następującą funkcję i wywołaj ją, przekazując swoją ramkę danych Pandy

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)

Wynik

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

Jeśli chcesz to uprościć, możesz użyć następującej funkcji, aby uzyskać brakujące wartości w%

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
źródło
10

Aby policzyć zera:

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

Aby policzyć NaN:

df.isnull().sum()

lub

df.isna().sum()
Pygirl
źródło
8

Możesz użyć metody value_counts i wydrukować wartości np.nan

s.value_counts(dropna = False)[np.nan]
Itachi
źródło
Miły! Ten jest najbardziej przydatny, jeśli chcesz liczyć zarówno NaN, jak i inne niż NaN. s.value_counts(dropna = False)
icemtel
8

Proszę użyć poniżej dla określonej liczby kolumn

dataframe.columnName.isnull().sum()
Anurag Bhakuni
źródło
3
df1.isnull().sum()

To załatwi sprawę.

Naveen Bharadwaj
źródło
3

Oto kod do liczenia Nullwartości w kolumnie:

df.isna().sum()
Sanket
źródło
3

Jest ładny artykuł Dzone z lipca 2017 r., Który szczegółowo opisuje różne sposoby podsumowywania wartości NaN. Sprawdź to tutaj .

Artykuł, który zacytowałem, zapewnia dodatkową wartość poprzez: (1) Wskazanie sposobu zliczania i wyświetlania liczby NaN dla każdej kolumny, dzięki czemu można łatwo zdecydować, czy odrzucić te kolumny, oraz (2) Wykazać sposób wyboru tych wierszy w specyficzne, które mają NaN, aby mogły być selektywnie odrzucane lub przypisywane.

Oto szybki przykład pokazujący użyteczność tego podejścia - z tylko kilkoma kolumnami być może jego przydatność nie jest oczywista, ale okazało się, że jest to pomocne w przypadku większych ramek danych.

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
śr
źródło
3

Inną prostą, jeszcze nie zasugerowaną opcją, aby po prostu policzyć NaN, byłoby dodanie kształtu, aby zwrócić liczbę wierszy za pomocą NaN.

df[df['col_name'].isnull()]['col_name'].shape
SlipperyD
źródło
2

df.isnull (). sum () da kolumnową sumę brakujących wartości.

Jeśli chcesz poznać sumę brakujących wartości w określonej kolumnie, poniższy kod będzie działał df.column.isnull (). Sum ()

K Pradeep Kumar Reddy
źródło
1

w oparciu o udzieloną odpowiedź i kilka ulepszeń to moje podejście

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
źródło
Wolędf.apply(lambda x: x.value_counts(dropna=False)[np.nan]/x.size*100)
K.-Michael Aye,
1

W przypadku, gdy chcesz uzyskać liczniki non-NA (brak) i NA (brak) w różnych grupach wyciąganych według grup:

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

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

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

Zwraca liczbę nie-NA, NA i całkowitą liczbę wpisów na grupę.

aysa
źródło
0

Użyłem rozwiązania zaproponowanego przez @sushmit w moim kodzie.

Możliwa może być również jego odmiana

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

Zaletą tego jest to, że zwraca wynik dla każdej kolumny w df odtąd.

vsdaking
źródło
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")

Podaje jako wynik:

     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
źródło
0

Załóżmy, że chcesz uzyskać liczbę brakujących wartości (NaN) w kolumnie (serii) znanej jako cena w ramce danych o nazwie recenzje

#import the dataframe
import pandas as pd

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

Aby uzyskać brakujące wartości, z n_missing_prices jako zmienną, wystarczy zrobić

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

sum jest tutaj kluczową metodą, próbowałem użyć count, zanim zdałem sobie sprawę, że suma jest właściwą metodą do zastosowania w tym kontekście

John R.
źródło
-1

Do swojego zadania możesz użyć pandas.DataFrame.dropna ( 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)

Za pomocą parametru thresh można zadeklarować maksymalną liczbę wartości NaN dla wszystkich kolumn w DataFrame.

Wyjścia kodu:

     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
źródło