Hoe de NaN-waarden in een kolom in Panda’s DataFrame te tellen

Ik wil het aantal NaNin elke kolom van mijn gegevens vinden, zodat ik een kolom kan laten vallen als deze minder NaNheeft dan een bepaalde drempel. Ik heb gezocht maar kon hier geen functie voor vinden. value_countsis te traag voor mij omdat de meeste waarden verschillend zijn en ik alleen geïnteresseerd ben in het aantal NaN.


Antwoord 1, autoriteit 100%

U kunt de isna()methode (of het is alias isnull()die ook compatibel is met oudere panda’s versies < 0.21.0) en vervolgens optellen om de NaN-waarden te tellen. Voor één kolom:

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

Voor meerdere kolommen werkt het ook:

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

Antwoord 2, autoriteit 14%

Laten we aannemen dat dfeen panda’s DataFrame is.

Dan,

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

Dit geeft het aantal NaN-waarden in elke kolom.

Als je wilt, NaN-waarden in elke rij,

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

Antwoord 3, autoriteit 13%

U kunt de totale lengte aftrekken van het aantalvan niet -nan-waarden:

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

U moet het timen op uw gegevens. Voor kleine series werd een 3x snellere snelheid verkregen in vergelijking met de isnull-oplossing.


Antwoord 4, autoriteit 6%

Op basis van het meest gestemde antwoord kunnen we eenvoudig een functie definiëren die ons een dataframe geeft om een ​​voorbeeld van de ontbrekende waarden en het % ontbrekende waarden in elke kolom te bekijken:

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

Antwoord 5, autoriteit 4%

Sinds pandas 0.14.1 is mijn suggestie hierom een ​​trefwoordargument in de value_counts-methode te hebben geïmplementeerd:

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

Antwoord 6, autoriteit 3%

Het onderstaande zal alle Nan-kolommen in aflopende volgorde afdrukken.

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

of

Het onderstaande zal de eerste 15 Nan-kolommen in aflopende volgorde afdrukken.

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

Antwoord 7, autoriteit 2%

Als het alleen maar nan-waarden in een panda-kolom telt, is dit een snelle manier

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

Antwoord 8, autoriteit 2%

df.isnull().sum()
geeft de kolomgewijze som van ontbrekende waarden.

Als u de som van ontbrekende waarden in een bepaalde kolom wilt weten, werkt de volgende code: df.column.isnull().sum()


Antwoord 9, autoriteit 2%

Als u Jupyter Notebook gebruikt, wat dacht u van….

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

of

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

of, zijn er ergens NaN’s in de gegevens, zo ja, waar?

df.isnull().any()

Antwoord 10, autoriteit 2%

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

U kunt de volgende functie gebruiken, die u output in Dataframe zal geven

  • Nulwaarden
  • Ontbrekende waarden
  • % van totale waarden
  • Totaal nul ontbrekende waarden
  • % Totaal nul ontbrekende waarden
  • Gegevenstype

Kopieer en plak de volgende functie en roep deze aan door uw panda’s Dataframe door te geven

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)

Uitvoer

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

Als u het eenvoudig wilt houden, kunt u de volgende functie gebruiken om ontbrekende waarden in % te krijgen

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

Antwoord 11, autoriteit 2%

Gebruik het onderstaande voor een bepaald aantal kolommen

dataframe.columnName.isnull().sum()

Antwoord 12, autoriteit 2%

Nullen tellen:

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

NaN tellen:

df.isnull().sum()

of

df.isna().sum()

Antwoord 13

Ik hoop dat dit helpt,

import pandas as pd
import numpy as np
df = pd.DataFrame({'a':[1,2,np.nan], 'b':[np.nan,1,np.nan],'c':[np.nan,2,np.nan], 'd':[np.nan,np.nan,np.nan]})

voer hier de afbeeldingsbeschrijving in

df.isnull().sum()/len(df) * 100

voer hier de afbeeldingsbeschrijving in

Thres = 40
(df.isnull().sum()/len(df) * 100 ) < Thres

voer hier de afbeeldingsbeschrijving in


Antwoord 14

df.isnull().sum() 
      //type: <class 'pandas.core.series.Series'>

of

df.column_name.isnull().sum()
     //type: <type 'numpy.int64'>

Antwoord 15

U kunt de methode value_counts gebruiken en waarden van np.nan afdrukken

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

Antwoord 16

Een andere eenvoudige optie die nog niet is voorgesteld, om alleen NaN’s te tellen, is het toevoegen van de vorm om het aantal rijen met NaN te retourneren.

df[df['col_name'].isnull()]['col_name'].shape

Antwoord 17

Voor de 1edeeltelling NaNhebben we meerdere manieren.

Methode 1 count, vanwege de countnegeert de NaNdie verschilt van size

print(len(df) - df.count())

Methode 2 isnull/ isnaketen met sum

print(df.isnull().sum())
#print(df.isna().sum())

Methode 3 describe/ info: merk op dat dit de ‘notnull’-waardetelling zal uitvoeren

print(df.describe())
#print(df.info())

Methode van numpy

print(np.count_nonzero(np.isnan(df.values),axis=0))

Voor het 2edeel van de vraag: als we de kolom bij de drempel willen laten vallen, kunnen we het proberen met dropna

thresh, optioneel Zoveel niet-NA-waarden vereisen.

Thresh = n # no null value require, you can also get the by int(x% * len(df))
df = df.dropna(thresh = Thresh, axis = 1)

Antwoord 18

df1.isnull().sum()

Dit zal het lukken.


Antwoord 19

Hier is de code voor het tellen van Null-waarden in de kolom:

df.isna().sum()

Antwoord 20

Er is een mooi Dzone-artikel uit juli 2017 waarin verschillende manieren worden beschreven om NaN-waarden samen te vatten. Bekijk het hier.

Het artikel dat ik heb geciteerd, biedt extra waarde door: (1) een manier te tonen om NaN-tellingen voor elke kolom te tellen en weer te geven, zodat men gemakkelijk kan beslissen om die kolommen al dan niet weg te gooien en (2) een manier te tonen om te selecteren die rijen in het bijzonder die NaN’s hebben, zodat ze selectief kunnen worden weggegooid of toegerekend.

Hier is een snel voorbeeld om het nut van de aanpak te demonstreren – met slechts een paar kolommen is het nut misschien niet duidelijk, maar ik vond het nuttig voor grotere dataframes.

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

Antwoord 21

op basis van het gegeven antwoord en enkele verbeteringen is dit mijn aanpak

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

Antwoord 22

In het geval dat u de niet-NA (niet-Geen) en NA (Geen)-tellingen voor verschillende groepen wilt laten ophalen door groupby:

gdf = df.groupby(['ColumnToGroupBy'])
def countna(x):
    return (x.isna()).sum()
gdf.agg(['count', countna, 'size'])

Dit geeft de tellingen van niet-NA, NA en het totale aantal inzendingen per groep terug.


Antwoord 23

Ik heb de door @sushmit voorgestelde oplossing in mijn code gebruikt.

Een mogelijke variant hiervan kan ook zijn

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

Voordeel hiervan is dat het voortaan het resultaat voor elk van de kolommen in de df retourneert.


Antwoord 24

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

Geeft als uitvoer:

    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

Antwoord 25

Stel dat u het aantal ontbrekende waarden (NaN) in een kolom(reeks) die bekend staat als prijs in een dataframe met de naam beoordelingen wilt ophalen

#import the dataframe
import pandas as pd
reviews = pd.read_csv("../input/wine-reviews/winemag-data-130k-v2.csv", index_col=0)

Om de ontbrekende waarden te krijgen, met n_missing_prices als variabele, doe je eenvoudig

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

som is hier de belangrijkste methode, ik probeerde count te gebruiken voordat ik me realiseerde dat sum de juiste methode is om in deze context te gebruiken


Antwoord 26

Ik gebruik deze lus om ontbrekende waarden voor elke kolom te tellen:

# check missing values
import numpy as np, pandas as pd
for col in df:
      print(col +': '+ np.str(df[col].isna().sum()))

Antwoord 27

Voor uw taak kunt u pandas.DataFrame.dropna gebruiken (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)

Met de thresh-parameter kunt u het maximale aantal NaN-waarden voor alle kolommen in DataFrame declareren.

Code-uitgangen:

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

Antwoord 28

Een oplossing is om null-waarderijen te vinden en deze om te zetten in een dataframe en vervolgens de lengte van het nieuwe dataframe te controleren.-

nan_rows = df[df['column_name'].isnull()]
print(len(nan_rows))

Antwoord 29

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

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

Retour aantal niet-NA/nul-waarnemingen in de serie

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes