Analyse de Données avec Python : Visualisations et Statistiques

Python est devenu l’un des langages les plus populaires pour l’analyse de données grâce à ses bibliothèques puissantes comme pandas, matplotlib et seaborn. Dans cet article, nous allons explorer comment analyser des données et créer des visualisations impressionnantes.

🚀 Pour voir les graphiques : Copiez le code dans un environnement Python (Jupyter Notebook, VS Code, Google Colab, etc.) et exécutez-le. Les graphiques s’afficheront dans votre interface de développement.

Installation des Bibliothèques

Commençons par installer les bibliothèques nécessaires :

pip install pandas matplotlib seaborn numpy jupyter

1. Chargement et Exploration des Données

Importation des bibliothèques

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
from datetime import datetime, timedelta

# Configuration du style
plt.style.use('seaborn-v0_8')
sns.set_palette("husl")

Création d’un dataset d’exemple

# Génération de données simulées pour les ventes d'une entreprise
np.random.seed(42)
dates = pd.date_range(start='2023-01-01', end='2023-12-31', freq='D')
n_days = len(dates)

# Données simulées
data = {
    'date': dates,
    'ventes': np.random.normal(1000, 200, n_days) + 50 * np.sin(np.arange(n_days) * 2 * np.pi / 365),
    'clients': np.random.poisson(50, n_days),
    'region': np.random.choice(['Nord', 'Sud', 'Est', 'Ouest'], n_days),
    'produit': np.random.choice(['A', 'B', 'C', 'D'], n_days),
    'prix_unitaire': np.random.uniform(10, 100, n_days)
}

df = pd.DataFrame(data)
df['revenus'] = df['ventes'] * df['prix_unitaire']
df['mois'] = df['date'].dt.month
df['trimestre'] = df['date'].dt.quarter

print("Aperçu des données :")
print(df.head())
print(f"\nInformations sur le dataset :")
print(df.info())

2. Statistiques Descriptives

Analyse des tendances temporelles

# Statistiques par mois
stats_mensuelles = df.groupby('mois').agg({
    'ventes': ['mean', 'std', 'sum'],
    'revenus': ['mean', 'sum'],
    'clients': 'mean'
}).round(2)

print("Statistiques mensuelles :")
print(stats_mensuelles)

Analyse par région et produit

# Analyse croisée région-produit
pivot_ventes = df.pivot_table(
    values='ventes', 
    index='region', 
    columns='produit', 
    aggfunc='sum'
)

print("Ventes par région et produit :")
print(pivot_ventes)

3. Visualisations avec Matplotlib (Python)

Code Python pour les graphiques

# Configuration de la figure
fig, axes = plt.subplots(2, 2, figsize=(15, 10))
fig.suptitle('Analyse des Ventes - 2023', fontsize=16, fontweight='bold')

# 1. Évolution des ventes dans le temps
axes[0, 0].plot(df['date'], df['ventes'], linewidth=1, alpha=0.7)
axes[0, 0].set_title('Évolution des Ventes Quotidiennes')
axes[0, 0].set_xlabel('Date')
axes[0, 0].set_ylabel('Ventes')
axes[0, 0].tick_params(axis='x', rotation=45)

# 2. Distribution des ventes
axes[0, 1].hist(df['ventes'], bins=30, alpha=0.7, edgecolor='black')
axes[0, 1].set_title('Distribution des Ventes')
axes[0, 1].set_xlabel('Ventes')
axes[0, 1].set_ylabel('Fréquence')

# 3. Ventes par région
ventes_region = df.groupby('region')['ventes'].sum()
axes[1, 0].bar(ventes_region.index, ventes_region.values, alpha=0.8)
axes[1, 0].set_title('Ventes Total par Région')
axes[1, 0].set_xlabel('Région')
axes[1, 0].set_ylabel('Ventes Total')

# 4. Ventes par mois
ventes_mois = df.groupby('mois')['ventes'].mean()
axes[1, 1].plot(ventes_mois.index, ventes_mois.values, marker='o', linewidth=2)
axes[1, 1].set_title('Ventes Moyennes par Mois')
axes[1, 1].set_xlabel('Mois')
axes[1, 1].set_ylabel('Ventes Moyennes')
axes[1, 1].set_xticks(range(1, 13))

plt.tight_layout()
plt.show()

4. Notebook Jupyter Interactif

Exécutez le Code Python en Ligne

Pour voir les graphiques en action, utilisez l’un de ces environnements en ligne :

Code Complet à Copier

Voici le code complet que vous pouvez copier dans n’importe lequel de ces environnements :

# Installation des bibliothèques (si nécessaire)
# !pip install matplotlib pandas seaborn numpy

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import seaborn as sns
from datetime import datetime, timedelta

# Configuration du style
plt.style.use('seaborn-v0_8')
sns.set_palette("husl")

# Génération de données simulées
np.random.seed(42)
dates = pd.date_range(start='2023-01-01', end='2023-12-31', freq='D')
n_days = len(dates)

data = {
    'date': dates,
    'ventes': np.random.normal(1000, 200, n_days) + 50 * np.sin(np.arange(n_days) * 2 * np.pi / 365),
    'clients': np.random.poisson(50, n_days),
    'region': np.random.choice(['Nord', 'Sud', 'Est', 'Ouest'], n_days),
    'produit': np.random.choice(['A', 'B', 'C', 'D'], n_days),
    'prix_unitaire': np.random.uniform(10, 100, n_days)
}

df = pd.DataFrame(data)
df['revenus'] = df['ventes'] * df['prix_unitaire']
df['mois'] = df['date'].dt.month
df['trimestre'] = df['date'].dt.quarter

print("Aperçu des données :")
print(df.head())
print(f"\nInformations sur le dataset :")
print(df.info())

# 1. Graphiques matplotlib
fig, axes = plt.subplots(2, 2, figsize=(15, 10))
fig.suptitle('Analyse des Ventes - 2023', fontsize=16, fontweight='bold')

# Évolution des ventes dans le temps
axes[0, 0].plot(df['date'], df['ventes'], linewidth=1, alpha=0.7)
axes[0, 0].set_title('Évolution des Ventes Quotidiennes')
axes[0, 0].set_xlabel('Date')
axes[0, 0].set_ylabel('Ventes')
axes[0, 0].tick_params(axis='x', rotation=45)

# Distribution des ventes
axes[0, 1].hist(df['ventes'], bins=30, alpha=0.7, edgecolor='black')
axes[0, 1].set_title('Distribution des Ventes')
axes[0, 1].set_xlabel('Ventes')
axes[0, 1].set_ylabel('Fréquence')

# Ventes par région
ventes_region = df.groupby('region')['ventes'].sum()
axes[1, 0].bar(ventes_region.index, ventes_region.values, alpha=0.8)
axes[1, 0].set_title('Ventes Total par Région')
axes[1, 0].set_xlabel('Région')
axes[1, 0].set_ylabel('Ventes Total')

# Ventes par mois
ventes_mois = df.groupby('mois')['ventes'].mean()
axes[1, 1].plot(ventes_mois.index, ventes_mois.values, marker='o', linewidth=2)
axes[1, 1].set_title('Ventes Moyennes par Mois')
axes[1, 1].set_xlabel('Mois')
axes[1, 1].set_ylabel('Ventes Moyennes')
axes[1, 1].set_xticks(range(1, 13))

plt.tight_layout()
plt.show()

# 2. Heatmap de corrélation avec seaborn
plt.figure(figsize=(10, 8))
correlation_matrix = df[['ventes', 'clients', 'prix_unitaire', 'revenus']].corr()
sns.heatmap(correlation_matrix, 
            annot=True, 
            cmap='coolwarm', 
            center=0,
            square=True,
            fmt='.2f')
plt.title('Matrice de Corrélation', fontsize=14, fontweight='bold')
plt.show()

# 3. Boxplot par région
plt.figure(figsize=(12, 6))
sns.boxplot(data=df, x='region', y='ventes', hue='produit')
plt.title('Distribution des Ventes par Région et Produit', fontsize=14, fontweight='bold')
plt.xlabel('Région')
plt.ylabel('Ventes')
plt.legend(title='Produit', bbox_to_anchor=(1.05, 1), loc='upper left')
plt.tight_layout()
plt.show()

# 4. Graphique de régression
plt.figure(figsize=(10, 6))
sns.scatterplot(data=df, x='clients', y='ventes', hue='region', alpha=0.6)
sns.regplot(data=df, x='clients', y='ventes', scatter=False, color='red')
plt.title('Relation entre Nombre de Clients et Ventes', fontsize=14, fontweight='bold')
plt.xlabel('Nombre de Clients')
plt.ylabel('Ventes')
plt.legend(title='Région', bbox_to_anchor=(1.05, 1), loc='upper left')
plt.tight_layout()
plt.show()

print("🎉 Tous les graphiques ont été générés avec succès !")

5. Visualisations Avancées avec Seaborn (Python)

Heatmap des corrélations

# Calcul de la matrice de corrélation
correlation_matrix = df[['ventes', 'clients', 'prix_unitaire', 'revenus']].corr()

plt.figure(figsize=(10, 8))
sns.heatmap(correlation_matrix, 
            annot=True, 
            cmap='coolwarm', 
            center=0,
            square=True,
            fmt='.2f')
plt.title('Matrice de Corrélation', fontsize=14, fontweight='bold')
plt.show()

Instructions d’Exécution

1. Cliquez sur l’un des liens ci-dessus (Google Colab, JupyterLite, ou Replit)
2. Copiez le code complet fourni
3. Collez-le dans l’environnement choisi
4. Exécutez le code cellule par cellule ou en une fois
5. Admirez les graphiques matplotlib et seaborn générés !

Résultats Attendus

Après exécution du code, vous verrez :

• 4 graphiques matplotlib dans une grille 2x2
• Heatmap de corrélation avec seaborn
• Boxplot par région et produit
• Graphique de régression avec nuage de points
• Statistiques des données dans la console

Boxplot par région

plt.figure(figsize=(12, 6))
sns.boxplot(data=df, x='region', y='ventes', hue='produit')
plt.title('Distribution des Ventes par Région et Produit', fontsize=14, fontweight='bold')
plt.xlabel('Région')
plt.ylabel('Ventes')
plt.legend(title='Produit', bbox_to_anchor=(1.05, 1), loc='upper left')
plt.tight_layout()
plt.show()

📦 Résultat : Des boxplots montrant la distribution des ventes pour chaque région, séparés par produit. Les boîtes montrent la médiane, les quartiles et les valeurs aberrantes.

Graphique de régression

plt.figure(figsize=(10, 6))
sns.scatterplot(data=df, x='clients', y='ventes', hue='region', alpha=0.6)
sns.regplot(data=df, x='clients', y='ventes', scatter=False, color='red')
plt.title('Relation entre Nombre de Clients et Ventes', fontsize=14, fontweight='bold')
plt.xlabel('Nombre de Clients')
plt.ylabel('Ventes')
plt.legend(title='Région', bbox_to_anchor=(1.05, 1), loc='upper left')
plt.tight_layout()
plt.show()

Résultat : Un nuage de points coloré par région avec une ligne de régression rouge montrant la relation entre le nombre de clients et les ventes.

5. Analyse Temporelle Avancée

Tendance et saisonnalité

# Calcul de la moyenne mobile sur 7 jours
df['ventes_ma7'] = df['ventes'].rolling(window=7).mean()

plt.figure(figsize=(15, 8))
plt.plot(df['date'], df['ventes'], alpha=0.3, label='Ventes quotidiennes')
plt.plot(df['date'], df['ventes_ma7'], linewidth=2, label='Moyenne mobile 7 jours')
plt.title('Évolution des Ventes avec Tendance', fontsize=14, fontweight='bold')
plt.xlabel('Date')
plt.ylabel('Ventes')
plt.legend()
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

Analyse des performances par trimestre

# Performance par trimestre
performance_trimestre = df.groupby('trimestre').agg({
    'ventes': ['sum', 'mean'],
    'revenus': 'sum',
    'clients': 'sum'
}).round(2)

print("Performance par Trimestre :")
print(performance_trimestre)

# Visualisation
fig, axes = plt.subplots(1, 3, figsize=(18, 5))

# Ventes totales par trimestre
ventes_trim = df.groupby('trimestre')['ventes'].sum()
axes[0].bar(ventes_trim.index, ventes_trim.values, color='skyblue', alpha=0.8)
axes[0].set_title('Ventes Total par Trimestre')
axes[0].set_xlabel('Trimestre')
axes[0].set_ylabel('Ventes Total')

# Revenus par trimestre
revenus_trim = df.groupby('trimestre')['revenus'].sum()
axes[1].bar(revenus_trim.index, revenus_trim.values, color='lightgreen', alpha=0.8)
axes[1].set_title('Revenus Total par Trimestre')
axes[1].set_xlabel('Trimestre')
axes[1].set_ylabel('Revenus Total')

# Clients par trimestre
clients_trim = df.groupby('trimestre')['clients'].sum()
axes[2].bar(clients_trim.index, clients_trim.values, color='salmon', alpha=0.8)
axes[2].set_title('Nombre Total de Clients par Trimestre')
axes[2].set_xlabel('Trimestre')
axes[2].set_ylabel('Nombre de Clients')

plt.tight_layout()
plt.show()

6. Analyse des Outliers

Détection des valeurs aberrantes

# Détection des outliers avec la méthode IQR
def detect_outliers_iqr(data, column):
    Q1 = data[column].quantile(0.25)
    Q3 = data[column].quantile(0.75)
    IQR = Q3 - Q1
    lower_bound = Q1 - 1.5 * IQR
    upper_bound = Q3 + 1.5 * IQR
    return data[(data[column] < lower_bound) | (data[column] > upper_bound)]

outliers_ventes = detect_outliers_iqr(df, 'ventes')
print(f"Nombre d'outliers détectés dans les ventes : {len(outliers_ventes)}")

# Visualisation des outliers
plt.figure(figsize=(12, 6))
sns.boxplot(data=df, y='ventes', x='region')
plt.title('Boxplot des Ventes par Région (avec Outliers)', fontsize=14, fontweight='bold')
plt.xlabel('Région')
plt.ylabel('Ventes')
plt.tight_layout()
plt.show()

7. Prédictions Simples

Modèle de régression linéaire simple

from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_squared_error

# Préparation des données
X = df[['clients', 'prix_unitaire']].values
y = df['ventes'].values

# Division train/test
split_point = int(0.8 * len(df))
X_train, X_test = X[:split_point], X[split_point:]
y_train, y_test = y[:split_point], y[split_point:]

# Entraînement du modèle
model = LinearRegression()
model.fit(X_train, y_train)

# Prédictions
y_pred = model.predict(X_test)

# Évaluation
r2 = r2_score(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)

print(f"R² Score: {r2:.3f}")
print(f"RMSE: {np.sqrt(mse):.2f}")

# Visualisation des prédictions
plt.figure(figsize=(12, 6))
plt.scatter(y_test, y_pred, alpha=0.6)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.xlabel('Ventes Réelles')
plt.ylabel('Ventes Prédites')
plt.title(f'Prédictions vs Réalité (R² = {r2:.3f})', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.show()

8. Tableau de Bord Interactif

Création d’un résumé exécutif

# Métriques clés
total_ventes = df['ventes'].sum()
total_revenus = df['revenus'].sum()
total_clients = df['clients'].sum()
ventes_moyennes = df['ventes'].mean()
meilleur_mois = df.groupby('mois')['ventes'].sum().idxmax()
meilleure_region = df.groupby('region')['ventes'].sum().idxmax()

print("=" * 50)
print("📊 RAPPORT D'ANALYSE DES VENTES 2023")
print("=" * 50)
print(f"💰 Ventes totales : {total_ventes:,.0f}")
print(f"💵 Revenus total : {total_revenus:,.0f} €")
print(f"👥 Total clients : {total_clients:,}")
print(f"📈 Ventes moyennes/jour : {ventes_moyennes:.0f}")
print(f"🏆 Meilleur mois : {meilleur_mois}")
print(f"🌍 Meilleure région : {meilleure_region}")
print("=" * 50)

Conclusion

Cet article a montré comment utiliser Python pour analyser des données de manière efficace. Les bibliothèques pandas, matplotlib et seaborn offrent des outils puissants pour :

• Explorer les données avec des statistiques descriptives
• Visualiser les tendances et patterns
• Détecter les anomalies et outliers
• Prédire les tendances futures
• Créer des tableaux de bord informatifs

Prochaines étapes

Pour aller plus loin, vous pourriez explorer :

• Machine Learning avec scikit-learn
• Visualisations interactives avec Plotly
• Analyse de séries temporelles avec statsmodels
• Big Data avec Dask ou Spark

Bon codage ! 🐍📊