Données manquantes Pandas

Exemple d'opération de perte de données avec Pandas

Dans la vie réelle, la perte de données est toujours un problème. Les domaines tels que l'apprentissage automatique et l'extraction de données rencontrent des problèmes graves en matière de précision des prédictions des modèles, car les valeurs manquantes entraînent une qualité de données médiocre. Dans ces domaines, le traitement des valeurs manquantes est un point principal pour rendre les modèles plus précis et efficaces.

Quand et pourquoi les données sont-elles perdues ?

Considérons une enquête en ligne sur un produit. Souvent, les gens ne partagent pas toutes les informations les concernant. Très peu de gens partagent leur expérience, mais ne partagent pas combien de temps ils ont utilisé le produit ; très peu de gens partagent le temps qu'ils ont utilisé le produit, leur expérience plutôt que leurs informations de contact. Par conséquent, une partie des données est toujours perdue d'une manière ou d'une autre, ce qui est très courant dans les situations réelles.
Maintenant, voyons comment utiliser Pandas pour traiter les valeurs manquantes (par exemple NA ou NaN).

# Importer la bibliothèque pandas
　import pandas as pd
　import numpy as np
　df = pd.DataFrame(np.random.randn(5,　3), index=['a', 'c', 'e', 'f',
　,'h'], columns=['one', 'two', 'three'])
　df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
　print(df)

Les résultats de l'exécution sont les suivants :

　　　　　　　one            two            three
a　　-0.576991　　-0.741695　　0.553172
b                NaN                NaN                NaN
c        0.744328　　-1.735166　　1.749580
NaN remplacé par '0':
　　　　　　　　　one            two            three
a　　-0.576991　　-0.741695　　0.553172
b        0.000000        0.000000        0.000000
c        0.744328　　-1.735166　　1.749580

En utilisant le reindexing, nous créons un DataFrame manquant des valeurs. Dans la sortie, NaN signifie que ce n'est pas un nombre.

Vérification des valeurs manquantes

Pour rendre la détection des valeurs manquantes plus facile (et différentes pour différents types de données de tableau dtypes), Pandas fournit les fonctions ISNULL() et NOTNULL(), qui sont également des méthodes pour les objets de séries et de DataFrame.-

Instance 1

　import pandas as pd
　import numpy as np
　　
　df = pd.DataFrame(np.random.randn(5,　3), index=['a', 'c', 'e', 'f',
　,'h'], columns=['one', 'two', 'three'])
　df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
　print(df['one'].isnull())

Les résultats de l'exécution sont les suivants :

　faux
　vrai
　faux
　vrai
　faux
　faux
　vrai
　faux
　Nom: one, type: bool

Instance 2

　import pandas as pd
　import numpy as np
　df = pd.DataFrame(np.random.randn(5,　3), index=['a', 'c', 'e', 'f',
　,'h'], columns=['one', 'two', 'three'])
　df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
　print(df['one'].notnull())

Les résultats de l'exécution sont les suivants :

　vrai
　faux
　vrai
　faux
　vrai
　vrai
　g    False
　h    True
　Nom: one, type: bool

Calcul des données manquantes

Calcul des données manquantes Si les données sont toutes inaptes, le résultat est inapte

Instance 1

　import pandas as pd
　import numpy as np
　df = pd.DataFrame(np.random.randn(5,　3), index=['a', 'c', 'e', 'f',
　,'h'], columns=['one', 'two', 'three'])
　df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
　print(df['one'].sum())

Les résultats de l'exécution sont les suivants :

　　　2.02357685917

Instance 2

　import pandas as pd
　import numpy as np
　df = pd.DataFrame(index=[01,2,3,4,5],columns=['one','two'])
　print(df['one'].sum())

Les résultats de l'exécution sont les suivants :

　　　nan

Nettoyage/Remplissage des données manquantes

Pandas propose plusieurs méthodes pour supprimer les valeurs manquantes. La fonction fillna peut utiliser les données non vides pour 'remplir' les valeurs NA de plusieurs manières.

Remplacement de NaN par une valeur scalaire

Le programme suivant montre comment remplacer 'NaN' par '0'.

　import pandas as pd
　import numpy as np
　df = pd.DataFrame(np.random.randn(3,　3), index=['a', 'c', 'e'],columns=['one',
　,'two', 'three'])
　df = df.reindex(['a', 'b', 'c'])
　print(df)
　print(("NaN remplacé par '0':"))
　print(df.fillna(0))

Les résultats de l'exécution sont les suivants :

　　　　　　　one            two            three
a　　-0.576991　　-0.741695　　0.553172
b                NaN                NaN                NaN
c        0.744328　　-1.735166　　1.749580
NaN remplacé par '0':
　　　　　　　　　one            two            three
a　　-0.576991　　-0.741695　　0.553172
b        0.000000        0.000000        0.000000
c        0.744328　　-1.735166　　1.749580

Ici, nous remplissons par zéro ; à la place, nous pouvons également remplir d'autres valeurs.

Remplissage en avant et en arrière de NA

En utilisant le concept de remplissage discuté dans le chapitre 'Reindexing', nous allons remplir les valeurs manquantes.

Instance 1

　import pandas as pd
　import numpy as np
　df = pd.DataFrame(np.random.randn(5,　3), index=['a', 'c', 'e', 'f',
　,'h'], columns=['one', 'two', 'three'])
　df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
　print(df.fillna(method='pad'))

Les résultats de l'exécution sont les suivants :

　　　　　　　one            two            three
a        0.077988　　　0.476149　　　0.965836
b        0.077988　　　0.476149　　　0.965836
c　　-0.390208　　-0.551605　　-2.301950
d　　-0.390208　　-0.551605　　-2.301950
e　　-2.000303　　-0.788201　　　1.510072
f　　-0.930230　　-0.670473　　　1.146615
g　　-0.930230　　-0.670473　　　1.146615
h        0.085100        0.532791　　　0.887415

Instance 2

　import pandas as pd
　import numpy as np
　df = pd.DataFrame(np.random.randn(5,　3), index=['a', 'c', 'e', 'f',
　,'h'], columns=['one', 'two', 'three'])
　df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
　print(df.fillna(method='backfill'))

Les résultats de l'exécution sont les suivants :

　　　　　　　one            two            three
a        0.077988　　　0.476149　　　0.965836
b　　-0.390208　　-0.551605　　-2.301950
c　　-0.390208　　-0.551605　　-2.301950
d　　-2.000303　　-0.788201　　　1.510072
e　　-2.000303　　-0.788201　　　1.510072
f　　-0.930230　　-0.670473　　　1.146615
g        0.085100        0.532791　　　0.887415
h        0.085100        0.532791　　　0.887415

Suppression des valeurs manquantes

Si vous souhaitez uniquement exclure les valeurs manquantes, utilisez la fonction dropna avec le paramètre axis ensemble. Par défaut, axis = 0, ce qui signifie que si une valeur NA se trouve dans une ligne, toute la ligne sera exclue.

Instance 1

　import pandas as pd
　import numpy as np
　df = pd.DataFrame(np.random.randn(5,　3), index=['a', 'c', 'e', 'f',
　,'h'], columns=['one', 'two', 'three'])
　df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
　print(df.dropna())

Les résultats de l'exécution sont les suivants :

　　
　　　one two three a 0.077988　0.476149　0.965836　c　-0.390208　-0.551605　-2.301950 e　-2.000303　-0.788201　1.510072　f　-0.930230　-0.670473　1.146615　h 0.085100 0.532791　0.887415

Instance 2

　import pandas as pd
　import numpy as np
　df = pd.DataFrame(np.random.randn(5,　3), index=['a', 'c', 'e', 'f',
　,'h'], columns=['one', 'two', 'three'])
　df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
　print(df.dropna(axis=1))

Les résultats de l'exécution sont les suivants :

　DataFrame vide
　Colonnes : []
　Index : [a, b, c, d, e, f, g, h]

Remplacement des valeurs manquantes (ou) génériques

Souvent, nous devons remplacer une valeur générique par une valeur spécifique. Nous pouvons réaliser cela en appliquant la méthode replace.
Remplacer les NA par des valeurs scalaires est un comportement équivalent à la fonction fillna().

Instance 1

　import pandas as pd
　import numpy as np
　df = pd.DataFrame({'one': [10,20,30,40,50,2000], 'two': [1000,0,30,40,50,60]})
　print(df.replace({1000:10,2000:60}))

Les résultats de l'exécution sont les suivants :

　　　one two
　0　10　10
　1　20 0
　2　30　30
　3　40　40
　4　50　50
　5　60　60

Instance 2

　import pandas as pd
　import numpy as np
　df = pd.DataFrame({'one': [10,20,30,40,50,2000], 'two': [1000,0,30,40,50,60]})
　print(df.replace({1000:10,2000:60)

Les résultats de l'exécution sont les suivants :

　　　one two
　0　10　10
　1　20 0
　2　30　30
　3　40　40
　4　50　50
　5　60　60