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

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ć .

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

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.

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)

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

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

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

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

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)

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

Aby policzyć zera:

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

Aby policzyć NaN:

df.isnull().sum()

lub

df.isna().sum()

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

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

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

dataframe.columnName.isnull().sum()

df1.isnull().sum()

To załatwi sprawę.

Oto kod do liczenia Nullwartości w kolumnie:

df.isna().sum()

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

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

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

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

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ę.

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.

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

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

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

pandas.Series.count
Series.count(level=None)[source]

Zwraca liczbę obserwacji innych niż NA / zero w serii

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