Panda DataFrame'deki bir sütundaki NaN değerleri nasıl sayılır

NaNBazı eşik değerlerden daha azsa, bu sütunları bırakacağım ki, sayısını bulmak istediğim verilerim var . Baktım, ama bunun için herhangi bir işlev bulamadım. var value_counts, ama benim için yavaş olurdu, çünkü değerlerin çoğu farklı ve NaNsadece saymak istiyorum .

Sen kullanabilirsiniz isna()yöntemi (ya da diğer adı var isnull()da eski panda sürümleri <0.21.0 ile uyumludur) ve daha sonra NaN değerlerini saymak toplamı. Bir sütun için:

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

Birkaç sütun için de çalışır:

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

Sen gelen toplam uzunluğu çıkarmak olabilir sayım nan olmayan değerlerin :

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

Verilerinize zaman ayırmalısınız. Küçük Serisi için isnullçözüm ile karşılaştırıldığında 3x hız var .

Varsayalım dfBir panda DataFrame .

Sonra,

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

Bu, her sütundaki NaN değerlerinin sayısını verecektir.

İhtiyacınız varsa, her satırdaki NaN değerleri,

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

En çok oylanan yanıta dayanarak, her bir sütundaki eksik değerleri ve eksik değerlerin yüzdesini önizlemek için bize bir veri çerçevesi veren bir işlevi kolayca tanımlayabiliriz:

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

Pandalar yana 0.14.1 benim önerim burada uygulamaya konmuştur value_counts yönteminde bir anahtar kelime argüman var:

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

Burada panda sütunundaki nan değerlerini saymak hızlı bir yolsa

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

Jupyter Notebook kullanıyorsanız, Peki ya ....

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

veya

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

veya verilerde herhangi bir yerde NaN var mı, evet ise, nerede?

 df.isnull().any()

Aşağıda tüm Nan sütunları azalan sırada yazdırılacaktır.

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

veya

Aşağıda ilk 15 Nan sütunu azalan sırada yazdırılacaktır.

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

Dataframe'de çıktı verecek olan aşağıdaki işlevi kullanabilirsiniz

• Sıfır Değerler
• Kayıp değerler
• Toplam Değerlerin Yüzdesi
• Toplam Sıfır Eksik Değerler
• Toplam Sıfır Eksik Değerlerin Yüzdesi
• Veri tipi

Aşağıdaki işlevi kopyalayıp yapıştırın ve pandalarınızı geçirerek çağırın Dataframe

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)

Çıktı

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

Basit tutmak istiyorsanız,% olarak eksik değerleri almak için aşağıdaki işlevi kullanabilirsiniz

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

Sıfırları saymak için:

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

NaN saymak için:

df.isnull().sum()

veya

df.isna().sum()

Belirli sütun sayısı için lütfen aşağıda kullanın

dataframe.columnName.isnull().sum()

Value_counts yöntemini ve np.nan değerlerini yazdırabilirsiniz

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

df1.isnull().sum()

Bu hile yapacak.

NullAkıllıca değerleri saymak için kod İşte :

df.isna().sum()

Temmuz 2017'den NaN değerlerini özetlemenin çeşitli yollarını açıklayan güzel bir Dzone makalesi var. Buradan kontrol edin .

Alıntı yaptığım makale şu şekilde ek değer sağlar: (1) Her sütun için NaN sayılarını saymanın ve görüntülemenin bir yolunu göstererek kişinin bu sütunları atıp atmayacağına kolayca karar verebilmesi ve (2) Bu satırları seçmenin bir yolunu gösterme seçici olarak atılabilmeleri veya emdirilmeleri için NaN'leri olan spesifiktir.

İşte yaklaşımın faydasını göstermek için hızlı bir örnek - sadece birkaç sütun ile belki de yararlılığı açık değildir, ancak daha büyük veri çerçeveleri için yardımcı olduğunu buldum.

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

Henüz NaN'leri saymak için önerilmeyen bir başka basit seçenek, NaN ile satır sayısını döndürmek için şekil eklemek olacaktır.

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

df.isnull (). sum (), sütunlara dayalı olarak eksik değerlerin toplamını verir.

Belirli bir sütundaki eksik değerlerin toplamını bilmek istiyorsanız, aşağıdaki kod df.column.isnull (). Sum ()

verilen cevaba ve bazı iyileştirmelere dayanarak bu benim yaklaşımım

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

Groupby tarafından çıkarılan farklı gruplar arasında NA olmayan (Hiçbiri olmayan) ve NA (Yok) sayılarını almanız gerekirse:

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

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

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

Bu, NA olmayan, NA olmayan grupların sayısını ve grup başına toplam girdi sayısını döndürür.

Kodumda @sushmit tarafından önerilen çözümü kullandım.

Aynı olası bir varyasyon da olabilir

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

Bunun avantajı, bundan sonra df'deki sütunların her biri için sonucu döndürmesidir.

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

Çıktı olarak verir:

     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

Diyelim ki, gözden geçirme adı verilen bir veri çerçevesinde fiyat olarak bilinen bir sütundaki (seri) eksik değerlerin (NaN) sayısını almak istiyorsunuz.

#import the dataframe
import pandas as pd

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

Değişken olarak n_missing_prices ile eksik değerleri almak için

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

sum buradaki anahtar yöntemdir, bu bağlamda kullanmak için doğru yöntem olduğunu fark etmeden önce sayı kullanmaya çalışıyordum

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

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

Serideki NA / null olmayan gözlemlerin dönüş sayısı

Göreviniz için pandas.DataFrame.dropna ( https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.dropna.html ) kullanabilirsiniz:

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)

Thresh parametresi ile DataFrame'deki tüm sütunlar için NaN değerleri için maksimum sayımı bildirebilirsiniz.

Kod çıktıları:

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