Python
Pandas Is Nan

Démystifier le NaN de Pandas : un guide pour les débutants

MoeNagy Dev

Comprendre les bases de pandas.isnull() et pandas.isna()

Explorer le concept de pandas.is_nan

Qu'est-ce que pandas.isnull() et pandas.isna() ?

Les fonctions pandas.isnull() et pandas.isna() sont utilisées pour identifier les valeurs manquantes dans un DataFrame ou une Series Pandas. Ces fonctions renvoient un masque booléen de même forme que l'entrée, où True indique une valeur manquante et False indique une valeur non manquante.

Voici un exemple :

import pandas as pd
 
# Créer un DataFrame d'exemple
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8]})
 
# Vérifier les valeurs manquantes
print(df.isnull())
#       A     B
# 0  False False
# 1  False  True
# 2   True False
# 3  False False

Dans l'exemple ci-dessus, la méthode df.isnull() renvoie un DataFrame booléen indiquant la présence de valeurs manquantes dans chaque cellule.

Comprendre la différence entre pandas.isnull() et pandas.isna()

Les fonctions pandas.isnull() et pandas.isna() sont essentiellement les mêmes et peuvent être utilisées de manière interchangeable. Les deux fonctions servent le même objectif d'identifier les valeurs manquantes dans un DataFrame ou une Series.

La principale différence est que pandas.isna() est une façon plus moderne et recommandée de vérifier les valeurs manquantes, car elle offre un meilleur support pour gérer différents types de données, y compris les valeurs NaN de NumPy, None de Python et les propres indicateurs de valeurs manquantes de Pandas.

Dans la plupart des cas, vous pouvez utiliser pandas.isna() au lieu de pandas.isnull() sans aucun problème. Cependant, si vous devez maintenir la compatibilité avec des versions plus anciennes de Pandas, vous devrez peut-être utiliser pandas.isnull().

Gérer les données manquantes avec pandas.is_nan

Une fois que vous avez identifié.--- titre: Gérer les valeurs manquantes avec pandas extrait: Voici comment utiliser pandas.isnull() ou pandas.isna() pour identifier et gérer les valeurs manquantes dans un DataFrame pandas.

Pour identifier les valeurs manquantes dans un DataFrame, vous pouvez utiliser les fonctions pandas.isnull() ou pandas.isna(). Une fois que vous avez identifié les valeurs manquantes, vous pouvez les gérer de différentes manières :

  1. Remplacer les valeurs manquantes : Vous pouvez remplacer les valeurs manquantes par une valeur spécifique ou une valeur calculée à partir des données.
df['A'] = df['A'].fillna(0)  # Remplacer les valeurs manquantes dans la colonne 'A' par 0
  1. Supprimer les lignes ou les colonnes avec des valeurs manquantes :
df = df.dropna(subset=['A', 'B'])  # Supprimer les lignes avec des valeurs manquantes dans les colonnes 'A' ou 'B'
  1. Imputer les valeurs manquantes : Vous pouvez utiliser diverses techniques d'imputation, comme la moyenne, la médiane ou le mode, pour remplir les valeurs manquantes.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])
  1. Interpoler les valeurs manquantes : Pour les données de séries temporelles, vous pouvez utiliser l'interpolation pour estimer les valeurs manquantes en fonction des données environnantes.
df = df.interpolate()  # Interpoler les valeurs manquantes dans le DataFrame

Utiliser pandas.isnull() et pandas.isna() dans la manipulation de données

Identifier les valeurs manquantes dans un DataFrame

Vous pouvez utiliser les fonctions pandas.isnull() ou pandas.isna() pour identifier les valeurs manquantes dans un DataFrame :

import pandas as pd
 
# Créer un DataFrame d'exemple
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8]})
 
# Vérifier les valeurs manquantes
print(df.isnull())
#       A     B
# 0  False False
# 1  False  True
# 2   True False
# 3  False False

Le DataFrame booléen résultant indique la présence de valeurs manquantes dans chaque cellule.

Gérer les valeurs manquantes avec pandas.isnull() et pandas.isna()

Vous pouvez utiliser le masque booléen renvoyé par pandas.isnull() ou pandas.isna() pour effectuer diverses opérations sur le DataFrame, comme :

  1. Remplacer les valeurs manquantes :
df['A'] = df['A'].fillna(0)
df['B'] = df['B'].fillna(df['B'].mean())
  1. Supprimer les lignes ou les colonnes avec des valeurs manquantes :
df = df.dropna(subset=['A', 'B'])
```---
Titre: Gestion des valeurs manquantes avec pandas
Extrait: Découvrez comment gérer les valeurs manquantes dans vos données avec pandas.
---
 
1. **Détection des valeurs manquantes**:
```python
import pandas as pd
 
# Vérifier les valeurs manquantes
df.isnull().sum()  # Afficher le nombre de valeurs manquantes par colonne
df.isna().any()  # Vérifier si une colonne contient des valeurs manquantes
  1. Suppression des lignes ou colonnes avec des valeurs manquantes:
# Supprimer les lignes avec des valeurs manquantes dans les colonnes 'A' ou 'B'
df = df.dropna(subset=['A', 'B'])  # Supprimer les lignes avec des valeurs manquantes dans les colonnes 'A' ou 'B'
df = df.dropna(how='all')  # Supprimer les lignes avec toutes les valeurs manquantes
df = df.dropna(axis=1)  # Supprimer les colonnes avec des valeurs manquantes
  1. Imputation des valeurs manquantes:
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])

Remplacement des valeurs manquantes par une valeur spécifique

Vous pouvez remplacer les valeurs manquantes par une valeur spécifique en utilisant la méthode fillna() :

# Remplacer les valeurs manquantes dans la colonne 'A' par 0
df['A'] = df['A'].fillna(0)
 
# Remplacer les valeurs manquantes dans la colonne 'B' par la moyenne de la colonne
df['B'] = df['B'].fillna(df['B'].mean())

Suppression des lignes ou colonnes avec des valeurs manquantes

Vous pouvez supprimer les lignes ou colonnes avec des valeurs manquantes en utilisant la méthode dropna() :

# Supprimer les lignes avec des valeurs manquantes dans les colonnes 'A' ou 'B'
df = df.dropna(subset=['A', 'B'])
 
# Supprimer les lignes avec toutes les valeurs manquantes
df = df.dropna(how='all')
 
# Supprimer les colonnes avec des valeurs manquantes
df = df.dropna(axis=1)

Techniques avancées avec pandas.isnull() et pandas.isna()

Combiner pandas.isnull() et pandas.isna() avec d'autres méthodes de DataFrame

Vous pouvez combiner les fonctions pandas.isnull() ou pandas.isna() avec d'autres méthodes de DataFrame pour effectuer des opérations plus complexes. Par exemple, vous pouvez les utiliser dans des filtres conditionnels, des transformations de données, etc.

# Filtrer les lignes avec des valeurs manquantes dans la colonne 'A'
filtered_df = df[df['A'].isnull()]
 
# Remplir les valeurs manquantes dans la colonne 'B' par la médiane des valeurs non manquantes de cette colonne
df['B'] = df['B'].fillna(df['B'].median())
 
# Créer une nouvelle colonne indiquant la présence de valeurs manquantes dans la colonne 'A'
df['has_missing_A'] = df['A'].isnull()

Filtrage conditionnel basé sur les valeurs manquantes

Vous pouvez utiliser le masque booléen renvoyé par pandas.isnull() ou pandas.isna() pour effectuer un filtrage conditionnel sur votre DataFrame :

# Filtrer.
```---
titre: Lignes avec valeurs manquantes dans la colonne 'A'
extrait:
  rows with missing values in column 'A'
  filtered_df = df[df['A'].isnull()]
 
  # Filter rows with non-missing values in column 'B'
  non_missing_df = df[~df['B'].isnull()]
 
#### Imputation de valeurs manquantes à l'aide de diverses techniques
En plus du remplacement simple de valeurs, vous pouvez utiliser des techniques plus avancées pour imputer les valeurs manquantes, comme :
 
1. **Imputation par la moyenne/médiane/mode** :
```python
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])
  1. Imputation par les plus proches voisins (KNN) :
from fancyimpute import KNNImputer
imputer = KNNImputer(n_neighbors=5)
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])
  1. Imputation itérative :
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
imputer = IterativeImputer()
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])

Ces techniques d'imputation avancées peuvent être particulièrement utiles lorsque vous êtes confronté à des schémas de données manquantes plus complexes ou à des caractéristiques interdépendantes.

Exploration de cas d'utilisation spécifiques pour pandas.isna()

Nettoyage et prétraitement des données avec pandas.isna()

L'un des principaux cas d'utilisation de pandas.isnull() et pandas.isna() se situe dans l'étape de nettoyage et de prétraitement des données d'un pipeline d'analyse de données ou d'apprentissage automatique. Ces fonctions peuvent vous aider à identifier et à gérer les valeurs manquantes, ce qui est une étape cruciale pour assurer la qualité et la fiabilité de vos données.

Voici un exemple de la façon dont vous pouvez utiliser pandas.isna() pour nettoyer et prétraiter un jeu de données :

import pandas as pd
 
# Chargement du jeu de données
df = pd.read_csv('dataset.csv')
 
# Identification des valeurs manquantes
missing_values = df.isna().sum()
print(missing_values)
 
# Suppression des lignes avec des valeurs manquantes dans n'importe quelle colonne
df = df.dropna()
 
# Remplissage des valeurs manquantes dans la colonne 'age' avec la médiane
df['age'] = df['age'].fillna(df['age'].median())
 
# Création d'une nouvelle colonne indiquant la présence de valeurs manquantes dans la colonne 'income'
df['has_m.---
titre: Gérer les valeurs manquantes dans les données
extrait: Cet article explore les différentes façons de gérer les valeurs manquantes dans les données en utilisant les fonctions `pandas.isnull()` et `pandas.isna()`.
---
 
Dans cet exemple, nous identifions d'abord le nombre de valeurs manquantes dans chaque colonne en utilisant `df.isna().sum()`. Nous supprimons ensuite les lignes avec des valeurs manquantes dans n'importe quelle colonne, et remplissons les valeurs manquantes dans la colonne 'age' avec la médiane. Enfin, nous créons une nouvelle colonne qui indique la présence de valeurs manquantes dans la colonne 'income'.
 
### Gérer les valeurs manquantes dans les séries temporelles
Lorsque l'on travaille avec des données de séries temporelles, la gestion des valeurs manquantes peut être particulièrement difficile. `pandas.isnull()` et `pandas.isna()` peuvent être combinés avec d'autres fonctions spécifiques aux séries temporelles pour gérer les valeurs manquantes dans ces jeux de données.
 
```python
import pandas as pd
 
# Créer un exemple de DataFrame de série temporelle
df = pd.DataFrame({'A': [1, 2, None, 4, 5], 'B': [5, None, 7, 8, 9]},
                  index=pd.date_range('2022-01-01', periods=5, freq='D'))
 
# Identifier les valeurs manquantes
print(df.isna())
#             A     B
# 2022-01-01 False False
# 2022-01-02 False  True
# 2022-01-03  True False
# 2022-01-04 False False
# 2022-01-05 False False
 
# Interpoler les valeurs manquantes
df = df.interpolate()
print(df)
#             A    B
# 2022-01-01  1  5.0
# 2022-01-02  2  6.0
# 2022-01-03  3  7.0
# 2022-01-04  4  8.0
# 2022-01-05  5  9.0

Dans cet exemple, nous créons un exemple de DataFrame de série temporelle avec des valeurs manquantes. Nous utilisons ensuite la méthode interpolate() pour estimer les valeurs manquantes en fonction des données environnantes.

Gérer les valeurs manquantes dans les modèles d'apprentissage automatique

Les valeurs manquantes peuvent avoir un impact significatif sur les performances des modèles d'apprentissage automatique. pandas.isnull() et pandas.isna() peuvent être utilisés pour identifier et gérer les valeurs manquantes avant d'alimenter les données dans un modèle d'apprentissage automatique.

import pandas as pd
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LinearRegression
 
# Charger le jeu de données
df = pd.read_csv('dataset.csv')
 
# Identifier les valeurs manquantes
missing_values = df.isna().sum()
print(missing_values)
 
# Imputer les valeurs manquantes
```---
titre: Imputer les valeurs manquantes à l'aide de l'imputation par la moyenne
extrait: |
  imputer = SimpleImputer(strategy='mean')
  X = imputer.fit_transform(df.drop('target', axis=1))
  y = df['target']
 
  # Entraîner un modèle de régression linéaire
  model = LinearRegression()
  model.fit(X, y)
 
Dans cet exemple, nous identifions d'abord les valeurs manquantes dans le jeu de données à l'aide de `df.isna().sum()`. Nous utilisons ensuite `SimpleImputer` de scikit-learn pour imputer les valeurs manquantes en utilisant la moyenne de chaque caractéristique. Enfin, nous entraînons un modèle de régression linéaire sur les données imputées.
 
La gestion des valeurs manquantes est une étape essentielle dans la préparation des données pour les modèles d'apprentissage automatique, car de nombreux modèles ne peuvent pas gérer directement les valeurs manquantes. En utilisant `pandas.isnull()` et `pandas.isna()`, vous pouvez vous assurer
 
## Fonctions
 
Les fonctions sont des blocs de code réutilisables qui effectuent une tâche spécifique. Elles peuvent accepter des entrées, effectuer des opérations et renvoyer des sorties. Les fonctions permettent d'organiser et de modulariser votre code, le rendant plus lisible et plus maintenable.
 
Voici un exemple d'une fonction simple qui calcule la surface d'un rectangle :
 
```python
def calculate_area(length, width):
    """
    Calcule la surface d'un rectangle.
 
    Args:
        length (float): La longueur du rectangle.
        width (float): La largeur du rectangle.
 
    Returns:
        float: La surface du rectangle.
    """
    area = length * width
    return area
 
# Utilisation
rectangle_length = 5.0
rectangle_width = 3.0
rectangle_area = calculate_area(rectangle_length, rectangle_width)
print(f"La surface du rectangle est de {rectangle_area} unités carrées.")

Dans cet exemple, la fonction calculate_area prend deux paramètres, length et width, et renvoie la surface calculée. La fonction comprend également une chaîne de documentation qui fournit une brève description de la fonction et les paramètres et valeurs de retour attendus.

Modules et Packages

La bibliothèque standard de Python fournit une large gamme de modules intégrés, qui sont des collections de fonctions, de classes et de variables. Vous pouvez également créer vos propres modules.--- excerpt: Modules et paquets pour organiser votre code et le rendre plus réutilisable.

Voici un exemple de création d'un module simple :

# my_module.py
def greet(name):
    """
    Salue la personne avec le nom donné.
 
    Args:
        name (str): Le nom de la personne à saluer.
 
    Returns:
        str: Le message de salutation.
    """
    return f"Bonjour, {name} !"

Pour utiliser le module, vous pouvez l'importer dans un autre fichier Python :

# main.py
import my_module
 
greeting = my_module.greet("Alice")
print(greeting)  # Sortie : Bonjour, Alice !

Les paquets sont des collections de modules organisées dans des répertoires. Ils vous permettent de regrouper des modules connexes et de fournir une structure hiérarchique à votre code. Voici un exemple de création d'un paquet simple :

my_package/
    __init__.py
    utils/
        __init__.py
        math_functions.py
        string_functions.py

Les fichiers __init__.py sont utilisés pour définir la structure du paquet et spécifier quels modules doivent être importés lorsque le paquet est importé.

# my_package/utils/math_functions.py
def add(a, b):
    return a + b
 
def subtract(a, b):
    return a - b
# main.py
from my_package.utils import math_functions
 
result = math_functions.add(5, 3)
print(result)  # Sortie : 8

Exceptions

Les exceptions sont des événements qui se produisent pendant l'exécution d'un programme et qui perturbent le flux normal des instructions du programme. Python dispose d'un mécanisme intégré de gestion des exceptions qui vous permet de gérer et de traiter ces situations inattendues.

Voici un exemple de gestion d'une exception ZeroDivisionError :

def divide(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        print("Erreur : Division par zéro.")
        return None
 
print(divide(10, 2))  # Sortie : 5.0
print(divide(10, 0))  # Sortie : Erreur : Division par zéro.

Dans cet exemple, la fonction divide tente de diviser le premier argument par le second argument. Si une ZeroDivisionError se produit, le programme affiche un message d'erreur et renvoie None.--- titre: Gestion des erreurs et des exceptions en Python extrait: DivisionError se produit, la fonction capture l'exception et affiche un message d'erreur, puis renvoie None.

Vous pouvez également créer des exceptions personnalisées en définissant vos propres classes d'exception qui héritent de la classe Exception intégrée ou de l'une de ses sous-classes.

class NegativeValueError(Exception):
    """Levée lorsqu'une valeur négative est rencontrée."""
    pass
 
def calculate_square_root(number):
    if number < 0:
        raise NegativeValueError("Impossible de calculer la racine carrée d'un nombre négatif.")
    return number ** 0.5
 
try:
    print(calculate_square_root(16))  # Sortie : 4.0
    print(calculate_square_root(-4))
except NegativeValueError as e:
    print(e)  # Sortie : Impossible de calculer la racine carrée d'un nombre négatif.

Dans cet exemple, la fonction calculate_square_root lève une exception NegativeValueError personnalisée si le nombre d'entrée est négatif. L'exception est ensuite capturée et gérée dans le bloc try-except.

Entrée/Sortie de fichier

Python fournit des fonctions et des méthodes intégrées pour lire et écrire dans des fichiers. La façon la plus courante de travailler avec des fichiers est d'utiliser la fonction open(), qui renvoie un objet de fichier qui peut être utilisé pour effectuer diverses opérations sur le fichier.

Voici un exemple de lecture et d'écriture dans un fichier :

# Écriture dans un fichier
with open("example.txt", "w") as file:
    file.write("Ceci est la première ligne.\n")
    file.write("Ceci est la deuxième ligne.\n")
 
# Lecture d'un fichier
with open("example.txt", "r") as file:
    contents = file.read()
    print(contents)
    # Sortie :
    # Ceci est la première ligne.
    # Ceci est la deuxième ligne.

Dans cet exemple, la fonction open() est utilisée pour ouvrir un fichier nommé "example.txt" en mode écriture ("w") et y écrire deux lignes de texte. Ensuite, le fichier est ouvert en mode lecture ("r") et son contenu est lu et affiché.

L'instruction with est utilisée pour s'assurer que le fichier est correctement fermé après la fin des opérations, même si une exception se produit.

Vous pouvez également lire les fichiers ligne par ligne.--- titre: Fichier Markdown avec traduction française extrait: Voici un fichier Markdown avec une traduction française.

Voici un exemple de boucle for pour lire un fichier ligne par ligne :

with open("example.txt", "r") as file:
    for line in file:
        print(line.strip())
    # Sortie :
    # Ceci est la première ligne.
    # Ceci est la deuxième ligne.

Dans cet exemple, la méthode strip() est utilisée pour supprimer le caractère de saut de ligne de chaque ligne.

Expressions régulières

Les expressions régulières (regex) sont un outil puissant pour la correspondance de motifs et la manipulation de texte. Le module intégré re de Python fournit un ensemble complet de fonctions et de méthodes pour travailler avec les expressions régulières.

Voici un exemple de l'utilisation des expressions régulières pour valider une adresse e-mail :

import re
 
def is_valid_email(email):
    """
    Vérifie si l'adresse e-mail donnée est valide.
 
    Args:
        email (str): L'adresse e-mail à valider.
 
    Returns:
        bool: True si l'adresse e-mail est valide, False sinon.
    """
    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
    if re.match(pattern, email):
        return True
    else:
        return False
 
print(is_valid_email("example@example.com"))  # Sortie : True
print(is_valid_email("invalid_email"))  # Sortie : False

Dans cet exemple, la fonction is_valid_email prend une adresse e-mail en entrée et utilise un motif d'expression régulière pour vérifier si l'adresse e-mail est valide. La fonction re.match() est utilisée pour appliquer le motif à l'adresse e-mail et renvoyer un résultat booléen.

Les expressions régulières peuvent être utilisées pour une grande variété de tâches de traitement de texte, telles que :

  • Rechercher des motifs spécifiques dans le texte
  • Extraire des informations du texte
  • Remplacer ou modifier le texte en fonction des motifs
  • Valider les données d'entrée

Bien que les expressions régulières puissent être puissantes, elles peuvent également devenir complexes et difficiles à lire, surtout pour les cas d'utilisation plus avancés. Il est important d'équilibrer l'utilisation des expressions régulières avec d'autres techniques de traitement de texte, telles que la manipulation de chaînes de caractères et les méthodes intégrées aux chaînes de caractères.

Conclusion

Dans ce tutoriel, vous avez appris sur divers sujets de niveau intermédiaire en P.--- title: Concepts essentiels de Python excerpt: Découvrez les concepts essentiels de Python, notamment les fonctions, les modules et les packages, la gestion des exceptions, l'entrée/sortie de fichiers et les expressions régulières.

Les concepts essentiels de Python, notamment les fonctions, les modules et les packages, la gestion des exceptions, l'entrée/sortie de fichiers et les expressions régulières, sont essentiels pour construire des applications Python plus complexes et robustes.

N'oubliez pas que la meilleure façon d'améliorer vos compétences en Python est de pratiquer, d'expérimenter et d'apprendre en continu. Explorez la bibliothèque standard de Python, lisez la documentation et participez aux communautés en ligne pour développer vos connaissances et vous tenir au courant des derniers développements dans l'écosystème Python.

Bon codage !

MoeNagy Dev.