Python
Pandas Crosstab: Un guide du débutant pour une analyse sans effort

Pandas Crosstab : Un guide du débutant pour une analyse sans effort

MoeNagy Dev

Qu'est-ce que le crosstab de pandas ?

La fonction crosstab() de la bibliothèque pandas est un outil puissant pour créer des tables de contingence, également connues sous le nom de tabulations croisées. Elle vous permet d'analyser la relation entre deux variables catégorielles ou plus en fournissant une représentation tabulaire de leur distribution de fréquence.

La fonction crosstab() prend une ou plusieurs séries ou variables catégorielles en entrée et génère une table bidimensionnelle, où les lignes représentent une variable et les colonnes représentent une autre variable. La table résultante montre le décompte ou la fréquence des combinaisons des variables d'entrée.

Les principales fonctionnalités et cas d'utilisation de crosstab() incluent :

  • Analyse de fréquence : Identification de la fréquence ou du décompte des différentes combinaisons de variables catégorielles.
  • Table de contingence : Création d'une table de contingence pour analyser la relation entre deux variables catégorielles ou plus.
  • Tableau croisé dynamique : Génération d'une sortie ressemblant à un tableau croisé dynamique, qui peut être personnalisée et analysée plus en détail.
  • Probabilités conditionnelles : Calcul des probabilités conditionnelles entre les variables.
  • Exploration des données : Exploration de la distribution et des relations de votre ensemble de données.

Création d'un crosstab simple

Commençons par générer un DataFrame d'exemple sur lequel travailler :

import pandas as pd
 
# Générer un DataFrame d'exemple
data = {
    'Genre': ['Homme', 'Femme', 'Homme', 'Femme', 'Homme', 'Femme'],
    'Âge': ['Jeune', 'Jeune', 'Vieux', 'Vieux', 'Jeune', 'Vieux'],
    'Nombre': [10, 8, 6, 12, 5, 9]
}
 
df = pd.DataFrame(data)

Maintenant, nous pouvons utiliser la fonction crosstab() pour créer un crosstab simple :

pd.crosstab(df['Genre'], df['Âge'])

Cela affichera un tableau qui montre le décompte de chaque combinaison de 'Genre' et 'Âge' dans le DataFrame.

Âge    Vieux  Jeune
Genre              
Femme     12      8
Homme      6     15

Les lignes représentent la variable 'Genre' et les colonnes représentent la variable 'Âge'. Les valeurs dans le tableau indiquent le décompte de chaque combinaison.

Personnalisation du crosstab

Vous pouvez personnaliser davantage la fonction crosstab() pour répondre à vos besoins. Explorons certaines des options disponibles.

Spécification des étiquettes de lignes et de colonnes

Vous pouvez fournir des étiquettes personnalisées pour les lignes et les colonnes à l'aide des paramètres index et columns :

pd.crosstab(df['Genre'], df['Âge'], rownames=['Genre'], colnames=['Âge'])

Cela générera la même sortie qu'auparavant, mais avec des étiquettes de lignes et de colonnes personnalisées.

Application de fonctions d'agrégation

Par défaut, crosstab() compte le nombre d'occurrences pour chaque combinaison de variables. Vous pouvez modifier ce comportement en appliquant une fonction d'agrégation à l'aide du paramètre aggfunc :

pd.crosstab(df['Genre'], df['Âge'], values=df['Nombre'], aggfunc=sum)

Cela créera un crosstab qui additionne les valeurs 'Nombre' pour chaque combinaison de 'Genre' et 'Âge'.

Gestion des valeurs manquantes

Si vos données contiennent des valeurs manquantes, vous pouvez contrôler leur traitement en utilisant les paramètres margins et margins_name :

pd.crosstab(df['Genre'], df['Âge'], margins=True, margins_name='Total')

Cela ajoutera une ligne et une colonne 'Total' au crosstab, fournissant les décomptes totaux pour chaque ligne et colonne, y compris le total global.

Techniques avancées de crosstab

Travail avec des index à niveaux multiples

La fonction crosstab() peut également gérer des index à niveaux multiples dans vos données. Créons un DataFrame d'exemple avec un index à niveaux multiples :

data = {
    ('Genre', ''): ['Homme', 'Femme', 'Homme', 'Femme', 'Homme', 'Femme'],
    ('Âge', ''): ['Jeune', 'Jeune', 'Vieux', 'Vieux', 'Jeune', 'Vieux'],
    ('Nombre', ''): [10, 8, 6, 12, 5, 9]
}
 
df = pd.DataFrame(data)
df.columns = pd.MultiIndex.from_tuples(df.columns)

Maintenant, nous pouvons créer un crosstab en utilisant l'index à niveaux multiples :

pd.crosstab(df[('Genre', '')], df[('Âge', '')])

La sortie aura un index à niveaux multiples pour les lignes et les colonnes, reflétant la structure des données d'entrée.

Normalisation de la sortie du crosstab

Vous pouvez normaliser la sortie du crosstab pour afficher les fréquences relatives au lieu des décomptes bruts. Cela peut être fait à l'aide du paramètre normalize :

pd.crosstab(df['Genre'], df['Âge'], normalize='index')

Cela normalisera le crosstab en divisant chaque valeur par la somme des lignes, ce qui donnera les pourcentages par ligne.

Visualisation des données crosstab

Pour visualiser les données du crosstab, vous pouvez utiliser diverses fonctions de tracé fournies par pandas ou d'autres bibliothèques de visualisation comme Matplotlib ou Seaborn. Par exemple :

import matplotlib.pyplot as plt
 
crosstab = pd.crosstab(df['Genre'], df['Âge'])
crosstab.plot(kind='bar', figsize=(8, 6))
plt.title('Crosstab Genre et Âge')
plt.xlabel('Genre')
plt.ylabel('Décompte')
plt.show()

Cela créera un graphique en barres des données du crosstab, ce qui peut être utile pour comprendre les relations entre les variables.

Filtrage et tri du crosstab

Filtrage du crosstab en fonction de critères

Vous pouvez filtrer le crosstab en fonction de critères spécifiques en utilisant les techniques standard d'indexation et de masquage booléen de pandas :

crosstab = pd.crosstab(df['Genre'], df['Âge'])
crosstab_filtré = crosstab.loc[crosstab['Jeune'] > 5]

Cela créera un nouveau crosstab qui inclut uniquement les lignes où la valeur de la colonne 'Jeune' est supérieure à 5.

Tri des lignes et des colonnes du crosstab

Pour trier les lignes et les colonnes du crosstab, vous pouvez utiliser la méthode sort_index() :

crosstab = pd.crosstab(df['Genre'], df['Âge'])

sorted_crosstab = crosstab.sort_index(axis=0, ascending=False)


Cela triera les lignes du crosstab par ordre décroissant.

### Combinaison de filtrage et de tri

Vous pouvez combiner le filtrage et le tri pour personnaliser davantage la sortie du crosstab :

```python
crosstab = pd.crosstab(df['Gender'], df['Age'])
filtered_sorted_crosstab = crosstab.loc[crosstab['Young'] > 5].sort_index(axis=0, ascending=False)

Ceci filtrera d'abord le crosstab pour n'inclure que les lignes où la valeur de la colonne 'Young' est supérieure à 5, puis triera les lignes par ordre décroissant.

Crosstabs avec des données catégorielles

Travail avec des variables catégorielles

Lorsque vous travaillez avec des variables catégorielles, il est important de vous assurer qu'elles sont correctement encodées en tant que types de données catégorielles. Vous pouvez utiliser la méthode astype() pour convertir une colonne en un type de données catégorielles :

df['Gender'] = df['Gender'].astype('category')
df['Age'] = df['Age'].astype('category')

Affichage du crosstab pour les caractéristiques catégorielles

Une fois que vous avez configuré vos variables catégorielles, vous pouvez créer un crosstab pour analyser les relations entre elles :

pd.crosstab(df['Gender'], df['Age'])

Cela affichera le crosstab pour les variables catégorielles 'Gender' et 'Age'.

Gestion des valeurs NaN dans les données catégorielles

Si vos données contiennent des valeurs NaN (manquantes) dans les variables catégorielles, vous pouvez les gérer en utilisant le paramètre dropna :

pd.crosstab(df['Gender'], df['Age'], dropna=False)

Cela inclura les valeurs NaN dans la sortie du crosstab, ce qui vous permettra d'analyser également les données manquantes.

Crosstabs avec des données de séries temporelles

Génération de crosstabs pour les données basées sur le temps

Si vos données contiennent des informations liées au temps, vous pouvez utiliser la fonction crosstab() pour analyser les relations dans le temps. Créons un DataFrame d'exemple avec une colonne de dates :

data = {
    'Date': ['2022-01-01', '2022-01-02', '2022-01-03', '2022-01-04', '2022-01-05', '2022-01-06'],
    'Gender': ['Male', 'Female', 'Male', 'Female', 'Male', 'Female'],
    'Age': ['Young', 'Young', 'Old', 'Old', 'Young', 'Old'],
    'Count': [10, 8, 6, 12, 5, 9]
}
 
df = pd.DataFrame(data)
df['Date'] = pd.to_datetime(df['Date'])

Maintenant, vous pouvez créer un crosstab en utilisant la colonne 'Date' comme l'une des variables :

pd.crosstab(df['Date'].dt.date, df['Gender'])

Cela générera un crosstab qui montre le compte de chaque sexe pour chaque date dans le DataFrame.

Analyse des tendances et des motifs dans le temps

Vous pouvez également analyser plus en détail les tendances et les motifs dans le crosstab basé sur le temps en utilisant des fonctions ou des visualisations supplémentaires de pandas :

crosstab = pd.crosstab(df['Date'].dt.date, df['Gender'])
crosstab.plot(kind='line', figsize=(10, 6))
plt.title('Nombre de genres au fil du temps')
plt.xlabel('Date')
plt.ylabel('Compte')
plt.show()

Ceci créera un graphique linéaire du nombre de genres au fil du temps, vous permettant d'identifier les tendances ou les motifs dans les données.

Gestion des opérations liées aux dates / heures

Lorsque vous travaillez avec des données basées sur le temps, vous devrez peut-être effectuer diverses opérations liées aux dates / heures, telles que le regroupement par année, mois ou jour. Vous pouvez utiliser l'accessoire dt sur la colonne 'Date' pour accéder à ces opérations :

pd.crosstab(df['Date'].dt.month, df['Gender'])

Cela créera un crosstab qui montre le compte de chaque genre pour chaque mois dans les données.

Combinaison du crosstab avec d'autres fonctions pandas

Intégration du crosstab avec groupby()

Vous pouvez combiner la fonction crosstab() avec la fonction groupby() pour effectuer des analyses plus complexes. Par exemple, vous pouvez d'abord regrouper les données selon une variable, puis créer un crosstab sur les données groupées :

grouped_df = df.groupby(['Gender', 'Age'])
pd.crosstab(grouped_df.groups.keys(), df['Date'].dt.date)

Cela créera un crosstab qui montre le compte de chaque combinaison de 'Gender' et 'Age' pour chaque date dans les données.

Combinaison du crosstab avec pivot_table()

La fonction crosstab() peut également être utilisée en conjonction avec la fonction pivot_table() pour effectuer des analyses de données plus avancées :

pivot_table = pd.pivot_table(df, index=['Gender', 'Age'], columns='Date', values='Count', aggfunc='sum')

Cela créera une table pivot qui montre la somme de 'Count' pour chaque combinaison de 'Gender' et 'Age' à différentes dates.

Exploration d'autres fonctions pandas pour crosstab

Bien que crosstab() soit un outil puissant, il existe d'autres fonctions pandas qui peuvent être utilisées en combinaison avec ou en alternative à crosstab(). Certains exemples incluent :

  • value_counts(): Obtenir les comptes de fréquence des valeurs uniques dans une série.
  • pivot(): Créer une table de pivotement de style de feuille de calcul en tant que DataFrame.
  • melt(): Dépiler un DataFrame du format large au format long.
  • cut() et qcut(): Regrouper des données continues en intervalles.

L'exploration de ces fonctions peut vous aider à élargir votre boîte à outils d'analyse de données et à trouver l'approche la plus adaptée à votre cas d'utilisation spécifique.

Fonctions

Les fonctions sont un concept fondamental en Python qui vous permet de regrouper un ensemble d'instructions et de les réutiliser dans votre code. Les fonctions peuvent prendre des paramètres d'entrée, effectuer des opérations et renvoyer un résultat.

Voici un exemple d'une fonction simple qui calcule la surface d'un rectangle :

def calculate_area(length, width):
    area = length * width
    return area
 
# Appeler la fonction et imprimer le résultat
result = calculate_area(5, 10)
print(f"La surface du rectangle est de {result} unités carrées.")

Dans cet exemple, la fonction calculate_area() prend deux paramètres, length (longueur) et width (largeur), et renvoie la surface calculée. Vous pouvez ensuite appeler la fonction et stocker le résultat dans la variable result, qui est ensuite imprimée dans la console.

Les fonctions peuvent également avoir des valeurs par défaut pour les paramètres, ce qui vous permet de les appeler sans fournir tous les arguments :

def greet(name, message="Hello"):
    print(f"{message}, {name}!")
 
greet("Alice")  # Sortie : Hello, Alice!

Saluer("Bob", "Salut") # Sortie : Salut, Bob!

Dans cet exemple, la fonction saluer() a une valeur par défaut de "Bonjour" pour le paramètre message, vous pouvez donc appeler la fonction avec seulement l'argument nom et elle utilisera le message par défaut.

Modules et Packages La conception modulaire de Python vous permet d'organiser votre code en composants réutilisables appelés modules. Les modules sont des fichiers Python contenant des fonctions, des classes et des variables qui peuvent être importées et utilisées dans d'autres parties de votre code.

Voici un exemple de création d'un module simple appelé math_utils.py :

def additionner(a, b):
    return a + b
 
def soustraire(a, b):
    return a - b
 
def multiplier(a, b):
    return a * b
 
def diviser(a, b):
    return a / b

Vous pouvez ensuite importer et utiliser les fonctions de ce module dans un autre fichier Python :

import math_utils
 
resultat = math_utils.additionner(5, 3)
print(resultat)  # Sortie : 8
 
resultat = math_utils.soustraire(10, 4)
print(resultat)  # Sortie : 6

Les modules peuvent également être organisés en packages, qui sont des répertoires contenant plusieurs modules. Cela vous permet de créer une structure hiérarchique pour votre code et de faciliter sa gestion.

Voici un exemple de structure de package :

mon_package/
    __init__.py
    math/
        __init__.py
        operations.py
        geometrie.py
    data/
        __init__.py
        file_utils.py
        database_utils.py

Dans cet exemple, le package mon_package contient deux sous-packages : math et data. Chaque sous-package a son propre ensemble de modules et les fichiers __init__.py permettent à Python de reconnaître ces répertoires comme des packages.

Vous pouvez ensuite importer et utiliser les fonctions des modules au sein du package :

from mon_package.math.operations import additionner, soustraire
from mon_package.data.file_utils import lire_fichier
 
resultat = additionner(5, 3)
print(resultat)  # Sortie : 8
 
donnees = lire_fichier("data.txt")
print(donnees)

Programmation Orientée Objet (POO) La programmation orientée objet (POO) est un paradigme de programmation qui se concentre sur la création d'objets, qui sont des instances de classes. Les classes définissent la structure et le comportement des objets, et les objets peuvent interagir les uns avec les autres pour résoudre des problèmes complexes.

Voici un exemple d'une simple classe représentant une personne :

class Personne:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age
 
    def saluer(self):
        print(f"Bonjour, je m'appelle {self.nom} et j'ai {self.age} ans.")
 
# Créer un objet Personne et appeler la méthode saluer
personne = Personne("Alice", 30)
personne.saluer()  # Sortie : Bonjour, je m'appelle Alice et j'ai 30 ans.

Dans cet exemple, la classe Personne a deux attributs (nom et age) et une méthode (saluer()). Lorsque vous créez un nouvel objet Personne, vous pouvez définir les valeurs initiales des attributs en utilisant la méthode __init__() qui est une méthode spéciale appelée le constructeur.

Vous pouvez également créer des sous-classes qui héritent d'une classe de base, ce qui vous permet d'étendre les fonctionnalités de la classe de base :

class Étudiant(Personne):
    def __init__(self, nom, age, classe):
        super().__init__(nom, age)
        self.classe = classe
 
    def étudier(self):
        print(f"{self.nom} étudie pour sa classe de {self.classe}.")
 
# Créer un objet Étudiant et appeler ses méthodes
étudiant = Étudiant("Bob", 15, "10ème")
étudiant.saluer()  # Sortie : Bonjour, je m'appelle Bob et j'ai 15 ans.
étudiant.étudier()  # Sortie : Bob étudie pour sa classe de 10ème.

Dans cet exemple, la classe Étudiant hérite de la classe Personne et ajoute un attribut classe et une méthode étudier(). La méthode __init__() de la classe Étudiant appelle la méthode __init__() de la classe Personne en utilisant la fonction super() pour initialiser les attributs nom et age.

Exceptions et Gestion des Erreurs Le mécanisme de gestion des exceptions de Python vous permet de gérer les situations inattendues dans votre code et de fournir un moyen d'aborder les erreurs de manière élégante. Les exceptions sont levées lorsque une erreur se produit lors de l'exécution d'un programme, et vous pouvez écrire du code pour attraper et gérer ces exceptions.

Voici un exemple de gestion d'une exception ZeroDivisionError :

def diviser(a, b):
    try:
        résultat = a / b
        return résultat
    except ZeroDivisionError:
        print("Erreur : Division par zéro non autorisée.")
        return None
 
print(diviser(10, 2))  # Sortie : 5.0
print(diviser(10, 0))  # Sortie : Erreur : Division par zéro non autorisée.

Dans cet exemple, la fonction diviser() utilise un bloc try-except pour capturer l'exception ZeroDivisionError. Si l'opération de division soulève l'exception, le code dans le bloc except est exécuté et un message est affiché à la console. Si la division réussit, le résultat est renvoyé.

Vous pouvez également définir vos propres exceptions personnalisées en créant une nouvelle classe qui hérite de la classe intégrée Exception :

class ErreurNombreNégatif(Exception):
    pass
 
def racine_carree(nombre):
    if nombre < 0:
        raise ErreurNombreNégatif("Erreur : Impossible de calculer la racine carrée d'un nombre négatif.")
    return nombre ** 0.5
 
try:
    print(racine_carree(16))  # Sortie : 4.0
    print(racine_carree(-4))
except ErreurNombreNégatif as e:
    print(e)  # Sortie : Erreur : Impossible de calculer la racine carrée d'un nombre négatif.

Dans cet exemple, la fonction racine_carree() lève une exception personnalisée ErreurNombreNégatif si le nombre d'entrée est négatif. Le bloc try-except attrape l'exception et affiche le message d'erreur.

Conclusion Dans ce tutoriel Python, vous avez appris divers concepts de niveau intermédiaire en Python, y compris les fonctions, les modules et les packages, la programmation orientée objet et la gestion des exceptions. Ces sujets sont essentiels pour la construction d'applications Python plus complexes et robustes. Rappelez-vous, la meilleure façon d'améliorer vos compétences en Python est de pratiquer l'écriture de code et de résoudre des problèmes. Expérimentez avec les exemples fournis dans ce tutoriel et essayez d'appliquer ces concepts à vos propres projets. De plus, continuez à explorer le vaste écosystème des bibliothèques et des frameworks Python, qui peuvent considérablement étendre les capacités de vos programmes Python.

Bon codage !

MoeNagy Dev