In Panda Python, qual è il modo migliore per verificare se un DataFrame ha uno (o più) valori NaN?

Conosco la funzione pd.isnan, ma questo restituisce un DataFrame di valori booleani per ogni elemento. Anche questo post qui non risponde esattamente alla mia domanda.

La risposta di jwilner è perfetta . Stavo esplorando per vedere se c'è un'opzione più veloce, poiché nella mia esperienza, sommare le matrici piatte è (stranamente) più veloce del conteggio. Questo codice sembra più veloce:

df.isnull().values.any()

Per esempio:

In [2]: df = pd.DataFrame(np.random.randn(1000,1000))

In [3]: df[df > 0.9] = pd.np.nan

In [4]: %timeit df.isnull().any().any()
100 loops, best of 3: 14.7 ms per loop

In [5]: %timeit df.isnull().values.sum()
100 loops, best of 3: 2.15 ms per loop

In [6]: %timeit df.isnull().sum().sum()
100 loops, best of 3: 18 ms per loop

In [7]: %timeit df.isnull().values.any()
1000 loops, best of 3: 948 µs per loop

df.isnull().sum().sum()è un po 'più lento, ma ovviamente ha ulteriori informazioni - il numero di NaNs.

Hai un paio di opzioni.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10,6))
# Make a few areas have NaN values
df.iloc[1:3,1] = np.nan
df.iloc[5,3] = np.nan
df.iloc[7:9,5] = np.nan

Ora il frame di dati è simile al seguente:

          0         1         2         3         4         5
0  0.520113  0.884000  1.260966 -0.236597  0.312972 -0.196281
1 -0.837552       NaN  0.143017  0.862355  0.346550  0.842952
2 -0.452595       NaN -0.420790  0.456215  1.203459  0.527425
3  0.317503 -0.917042  1.780938 -1.584102  0.432745  0.389797
4 -0.722852  1.704820 -0.113821 -1.466458  0.083002  0.011722
5 -0.622851 -0.251935 -1.498837       NaN  1.098323  0.273814
6  0.329585  0.075312 -0.690209 -3.807924  0.489317 -0.841368
7 -1.123433 -1.187496  1.868894 -2.046456 -0.949718       NaN
8  1.133880 -0.110447  0.050385 -1.158387  0.188222       NaN
9 -0.513741  1.196259  0.704537  0.982395 -0.585040 -1.693810

• Opzione 1 : df.isnull().any().any()- Questo restituisce un valore booleano

Sai isnull()quale restituirebbe un frame di dati come questo:

       0      1      2      3      4      5
0  False  False  False  False  False  False
1  False   True  False  False  False  False
2  False   True  False  False  False  False
3  False  False  False  False  False  False
4  False  False  False  False  False  False
5  False  False  False   True  False  False
6  False  False  False  False  False  False
7  False  False  False  False  False   True
8  False  False  False  False  False   True
9  False  False  False  False  False  False

Se lo fai df.isnull().any(), puoi trovare solo le colonne che hanno NaNvalori:

0    False
1     True
2    False
3     True
4    False
5     True
dtype: bool

Un altro .any()ti dirà se uno dei precedenti èTrue

> df.isnull().any().any()
True

• Opzione 2 : df.isnull().sum().sum()- Questo restituisce un numero intero del numero totale di NaNvalori:

Funziona allo stesso modo .any().any()di prima, fornendo prima una somma del numero di NaNvalori in una colonna, quindi la somma di quei valori:

df.isnull().sum()
0    0
1    2
2    0
3    1
4    0
5    2
dtype: int64

Infine, per ottenere il numero totale di valori NaN nel DataFrame:

df.isnull().sum().sum()
5

Per scoprire quali righe hanno NaN in una colonna specifica:

nan_rows = df[df['name column'].isnull()]

Se hai bisogno di sapere quante righe ci sono con "una o più NaNs":

df.isnull().T.any().T.sum()

O se è necessario estrarre queste righe ed esaminarle:

nan_rows = df[df.isnull().T.any().T]

df.isnull().any().any() dovrebbe farlo.

Aggiungendo alla risposta geniale di Hobs, sono molto nuovo in Python e Panda, quindi per favore fai notare se sbaglio.

Per scoprire quali righe hanno NaN:

nan_rows = df[df.isnull().any(1)]

eseguirà la stessa operazione senza la necessità di trasporre specificando l'asse di any () come 1 per verificare se "True" è presente nelle righe.

Sintassi super semplice: df.isna().any(axis=None)

A partire da v0.23.2 , è possibile utilizzare DataFrame.isna+ DataFrame.any(axis=None)dove axis=Nonespecifica la riduzione logica sull'intero DataFrame.

# Setup
df = pd.DataFrame({'A': [1, 2, np.nan], 'B' : [np.nan, 4, 5]})
df
     A    B
0  1.0  NaN
1  2.0  4.0
2  NaN  5.0

df.isna()

       A      B
0  False   True
1  False  False
2   True  False

df.isna().any(axis=None)
# True

Alternative utili

numpy.isnan
Un'altra opzione performante se stai eseguendo versioni precedenti di Panda.

np.isnan(df.values)

array([[False,  True],
       [False, False],
       [ True, False]])

np.isnan(df.values).any()
# True

In alternativa, controlla la somma:

np.isnan(df.values).sum()
# 2

np.isnan(df.values).sum() > 0
# True

Series.hasnans
Puoi anche chiamare ripetutamente Series.hasnans. Ad esempio, per verificare se una singola colonna ha NaNs,

df['A'].hasnans
# True

E per verificare se una colonna ha NaN, puoi usare una comprensione con any(che è un'operazione di cortocircuito).

any(df[c].hasnans for c in df)
# True

Questo è in realtà molto veloce.

Poiché nessuno ha menzionato, c'è solo un'altra variabile chiamata hasnans.

df[i].hasnansverrà generato Truese uno o più dei valori nella serie panda sono NaN, in Falsecaso contrario. Si noti che non è una funzione.

panda versione '0.19.2' e '0.20.2'

Dal momento che pandasdeve scoprirlo DataFrame.dropna(), ho dato un'occhiata a come lo implementano e ho scoperto che ne hanno fatto uso DataFrame.count(), che conta tutti i valori non nulli in DataFrame. Cf. codice sorgente di Panda . Non ho analizzato questa tecnica, ma immagino che gli autori della biblioteca abbiano probabilmente fatto una scelta saggia su come farlo.

lascia che dfsia il nome del Pandas DataFrame e qualsiasi valore che numpy.nanè un valore nullo.

1. Se vuoi vedere quali colonne hanno valori null e quali no (solo Vero e Falso)

   df.isnull().any()

2. Se vuoi vedere solo le colonne che hanno valori null

   df.loc[:, df.isnull().any()].columns

3. Se vuoi vedere il conteggio dei null in ogni colonna

   df.isna().sum()

4. Se vuoi vedere la percentuale di null in ogni colonna

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

5. Se vuoi vedere la percentuale di null nelle colonne solo con null: df.loc[:,list(df.loc[:,df.isnull().any()].columns)].isnull().sum()/(len(df))*100

MODIFICA 1:

Se vuoi vedere dove mancano visivamente i tuoi dati:

import missingno
missingdata_df = df.columns[df.isnull().any()].tolist()
missingno.matrix(df[missingdata_df])

Basta usare math.isnan (x) , Restituisce True se x è un NaN (non un numero) e False in caso contrario.

df.isnull().sum()

Questo ti darà il conteggio di tutti i valori NaN presenti nei rispettivi colori di DataFrame.

Ecco un altro modo interessante di trovare null e sostituirlo con un valore calcolato

    #Creating the DataFrame

    testdf = pd.DataFrame({'Tenure':[1,2,3,4,5],'Monthly':[10,20,30,40,50],'Yearly':[10,40,np.nan,np.nan,250]})
    >>> testdf2
       Monthly  Tenure  Yearly
    0       10       1    10.0
    1       20       2    40.0
    2       30       3     NaN
    3       40       4     NaN
    4       50       5   250.0

    #Identifying the rows with empty columns
    nan_rows = testdf2[testdf2['Yearly'].isnull()]
    >>> nan_rows
       Monthly  Tenure  Yearly
    2       30       3     NaN
    3       40       4     NaN

    #Getting the rows# into a list
    >>> index = list(nan_rows.index)
    >>> index
    [2, 3]

    # Replacing null values with calculated value
    >>> for i in index:
        testdf2['Yearly'][i] = testdf2['Monthly'][i] * testdf2['Tenure'][i]
    >>> testdf2
       Monthly  Tenure  Yearly
    0       10       1    10.0
    1       20       2    40.0
    2       30       3    90.0
    3       40       4   160.0
    4       50       5   250.0

Ho usato il seguente e ho digitato il casting su una stringa e verificato il valore nan

   (str(df.at[index, 'column']) == 'nan')

Questo mi permette di verificare un valore specifico in una serie e non solo di restituirlo se questo è contenuto da qualche parte all'interno della serie.

Il migliore sarebbe usare:

df.isna().any().any()

Ecco perché . Quindi isna()è usato per definire isnull(), ma entrambi sono identici ovviamente.

Questo è ancora più veloce della risposta accettata e copre tutti gli array di panda 2D.

Oppure puoi usare .info()su DFcome:

df.info(null_counts=True) che restituisce il numero di righe non_null in una colonna come:

<class 'pandas.core.frame.DataFrame'>
Int64Index: 3276314 entries, 0 to 3276313
Data columns (total 10 columns):
n_matches                          3276314 non-null int64
avg_pic_distance                   3276314 non-null float64

import missingno as msno
msno.matrix(df)  # just to visualize. no missing value.

df.apply(axis=0, func=lambda x : any(pd.isnull(x)))

Controllerà per ogni colonna se contiene Nan o no.

Possiamo vedere i valori nulli presenti nell'insieme di dati generando heatmap utilizzando Seaborn modulo heatmap

import pandas as pd
import seaborn as sns
dataset=pd.read_csv('train.csv')
sns.heatmap(dataset.isnull(),cbar=False)

Non solo è possibile verificare l'esistenza di un "NaN", ma anche ottenere la percentuale di "NaN" in ciascuna colonna utilizzando quanto segue,

df = pd.DataFrame({'col1':[1,2,3,4,5],'col2':[6,np.nan,8,9,10]})  
df  

   col1 col2  
0   1   6.0  
1   2   NaN  
2   3   8.0  
3   4   9.0  
4   5   10.0  


df.isnull().sum()/len(df)  
col1    0.0  
col2    0.2  
dtype: float64

A seconda del tipo di dati con cui hai a che fare, puoi anche ottenere i conteggi dei valori di ogni colonna durante l'esecuzione dell'EDA impostando dropna su False.

for col in df:
   print df[col].value_counts(dropna=False)

Funziona bene con variabili categoriche, non tanto quando si hanno molti valori univoci.