Python et Data Science : Analyse de Données

La data science est devenue l'un des domaines les plus prometteurs de l'informatique, et Python s'est imposé comme le langage de référence dans ce secteur. Grâce à son écosystème riche en bibliothèques spécialisées, Python permet d'analyser, visualiser et modéliser les données avec une efficacité remarquable.

Pourquoi Python pour la Data Science ?

Python offre plusieurs avantages qui en font le choix privilégié des data scientists :

• Simplicité d'apprentissage : Syntaxe claire et intuitive
• Écosystème riche : Nombreuses bibliothèques spécialisées
• Communauté active : Support et ressources abondantes
• Intégration facile : Compatible avec de nombreux outils et plateformes
• Polyvalence : De l'analyse exploratoire au déploiement en production

Les Bibliothèques Essentielles

NumPy : Le Fondement du Calcul Numérique

NumPy (Numerical Python) est la bibliothèque de base pour le calcul scientifique en Python. Elle fournit des tableaux multidimensionnels performants et des fonctions mathématiques.

import numpy as np

# Création d'un tableau NumPy
donnees = np.array([1, 2, 3, 4, 5])
print(f"Tableau : {donnees}")
print(f"Moyenne : {np.mean(donnees)}")
print(f"Écart-type : {np.std(donnees)}")

# Opérations vectorisées
tableau_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(f"Somme par colonne : {np.sum(tableau_2d, axis=0)}")
print(f"Somme par ligne : {np.sum(tableau_2d, axis=1)}")

Pandas : Manipulation et Analyse de Données

Pandas est la bibliothèque incontournable pour la manipulation de données structurées. Elle offre des structures de données flexibles comme les DataFrames.

import pandas as pd

# Création d'un DataFrame
donnees_ventes = {
    'produit': ['Ordinateur', 'Téléphone', 'Tablette', 'Souris', 'Clavier'],
    'prix': [1200, 800, 600, 25, 75],
    'quantite': [10, 25, 15, 100, 50],
    'categorie': ['Informatique', 'Mobile', 'Mobile', 'Accessoire', 'Accessoire']
}

df = pd.DataFrame(donnees_ventes)
print(df)

# Calculs et analyses
df['total'] = df['prix'] * df['quantite']
print(f"\nChiffre d'affaires total : {df['total'].sum()}€")

# Groupement par catégorie
groupes = df.groupby('categorie')['total'].sum()
print(f"\nCA par catégorie :\n{groupes}")

# Statistiques descriptives
print(f"\nStatistiques :\n{df.describe()}")

Matplotlib et Seaborn : Visualisation de Données

La visualisation est cruciale en data science. Matplotlib et Seaborn permettent de créer des graphiques informatifs et esthétiques.

import matplotlib.pyplot as plt
import seaborn as sns

# Configuration de Seaborn pour de beaux graphiques
sns.set_style("whitegrid")
plt.figure(figsize=(12, 8))

# Graphique en barres avec Matplotlib
plt.subplot(2, 2, 1)
categories = df.groupby('categorie')['total'].sum()
plt.bar(categories.index, categories.values)
plt.title('Chiffre d\'affaires par catégorie')
plt.ylabel('CA (€)')

# Histogramme des prix
plt.subplot(2, 2, 2)
plt.hist(df['prix'], bins=10, alpha=0.7)
plt.title('Distribution des prix')
plt.xlabel('Prix (€)')
plt.ylabel('Fréquence')

# Graphique de corrélation avec Seaborn
plt.subplot(2, 2, 3)
sns.scatterplot(data=df, x='prix', y='quantite', hue='categorie')
plt.title('Relation Prix-Quantité')

# Boîte à moustaches
plt.subplot(2, 2, 4)
sns.boxplot(data=df, x='categorie', y='prix')
plt.title('Distribution des prix par catégorie')
plt.xticks(rotation=45)

plt.tight_layout()
plt.show()

Analyse Exploratoire de Données (EDA)

L'analyse exploratoire est une étape fondamentale qui permet de comprendre la structure et les caractéristiques des données.

# Chargement d'un jeu de données plus complexe
# Supposons un fichier CSV avec des données de ventes
# df_ventes = pd.read_csv('ventes_entreprise.csv')

# Aperçu des données
print("Informations générales :")
print(df.info())
print("\nPremières lignes :")
print(df.head())

# Détection des valeurs manquantes
print(f"\nValeurs manquantes :\n{df.isnull().sum()}")

# Analyse des corrélations
correlation_matrix = df[['prix', 'quantite', 'total']].corr()
print(f"\nMatrice de corrélation :\n{correlation_matrix}")

# Visualisation de la matrice de corrélation
plt.figure(figsize=(8, 6))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', center=0)
plt.title('Matrice de Corrélation')
plt.show()

Nettoyage et Préparation des Données

# Traitement des valeurs manquantes
# df_clean = df.dropna()  # Supprimer les lignes avec des valeurs manquantes
# df_clean = df.fillna(df.mean())  # Remplacer par la moyenne

# Traitement des doublons
df_sans_doublons = df.drop_duplicates()

# Transformation des types de données
df['prix'] = pd.to_numeric(df['prix'], errors='coerce')

# Création de nouvelles variables
df['prix_unitaire_categorie'] = df['prix'] / df.groupby('categorie')['prix'].transform('mean')

# Encodage des variables catégorielles
df_encoded = pd.get_dummies(df, columns=['categorie'], prefix='cat')
print(df_encoded.head())

Introduction au Machine Learning avec Scikit-learn

Scikit-learn est la bibliothèque de référence pour le machine learning en Python. Voici un exemple de prédiction simple :

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# Préparation des données pour un modèle de régression
# Prédire le prix en fonction de la quantité
X = df[['quantite']].values
y = df['prix'].values

# Division en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Création et entraînement du modèle
modele = LinearRegression()
modele.fit(X_train, y_train)

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

# Évaluation du modèle
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"Erreur quadratique moyenne : {mse:.2f}")
print(f"Coefficient de détermination R² : {r2:.2f}")

# Visualisation des résultats
plt.figure(figsize=(10, 6))
plt.scatter(X_test, y_test, color='blue', label='Données réelles')
plt.plot(X_test, y_pred, color='red', linewidth=2, label='Prédictions')
plt.xlabel('Quantité')
plt.ylabel('Prix')
plt.title('Régression Linéaire : Prix vs Quantité')
plt.legend()
plt.show()

Projet Pratique : Analyse des Ventes

Mettons en pratique ces concepts avec un projet complet d'analyse de données de ventes :

class AnalyseurVentes:
    def __init__(self, donnees):
        self.df = donnees
        self.prepare_data()
    
    def prepare_data(self):
        """Préparation et nettoyage des données"""
        # Calcul du chiffre d'affaires
        self.df['ca'] = self.df['prix'] * self.df['quantite']
        
        # Ajout de la date (simulation)
        self.df['mois'] = np.random.choice(['Jan', 'Fév', 'Mar', 'Avr'], len(self.df))
    
    def analyser_tendances(self):
        """Analyse des tendances de ventes"""
        # Performance par catégorie
        perf_cat = self.df.groupby('categorie').agg({
            'ca': ['sum', 'mean'],
            'quantite': 'sum'
        }).round(2)
        
        print("Performance par catégorie :")
        print(perf_cat)
        
        # Évolution mensuelle
        perf_mois = self.df.groupby('mois')['ca'].sum().sort_values(ascending=False)
        print(f"\nCA par mois :\n{perf_mois}")
        
        return perf_cat, perf_mois
    
    def detecter_anomalies(self):
        """Détection d'anomalies dans les prix"""
        Q1 = self.df['prix'].quantile(0.25)
        Q3 = self.df['prix'].quantile(0.75)
        IQR = Q3 - Q1
        
        seuil_bas = Q1 - 1.5 * IQR
        seuil_haut = Q3 + 1.5 * IQR
        
        anomalies = self.df[(self.df['prix'] < seuil_bas) | (self.df['prix'] > seuil_haut)]
        print(f"Anomalies détectées : {len(anomalies)} produits")
        return anomalies
    
    def generer_rapport(self):
        """Génération d'un rapport complet"""
        rapport = {
            'total_ca': self.df['ca'].sum(),
            'prix_moyen': self.df['prix'].mean(),
            'produit_plus_vendu': self.df.loc[self.df['quantite'].idxmax(), 'produit'],
            'categorie_dominante': self.df.groupby('categorie')['ca'].sum().idxmax()
        }
        
        print("=== RAPPORT D'ANALYSE ===")
        for cle, valeur in rapport.items():
            print(f"{cle}: {valeur}")
        
        return rapport

# Utilisation de la classe
analyseur = AnalyseurVentes(df)
perf_cat, perf_mois = analyseur.analyser_tendances()
anomalies = analyseur.detecter_anomalies()
rapport = analyseur.generer_rapport()

Bonnes Pratiques en Data Science

• Documentation du code : Commentez vos analyses pour faciliter la reproduction
• Versionning des données : Gardez une trace des transformations appliquées
• Validation croisée : Testez vos modèles sur plusieurs échantillons
• Visualisation claire : Créez des graphiques lisibles et informatifs
• Éthique des données : Respectez la confidentialité et les biais potentiels

Outils Complémentaires

Pour aller plus loin dans votre parcours data science :

• Jupyter Notebooks : Environnement interactif idéal pour l'exploration
• Plotly : Visualisations interactives avancées
• TensorFlow/PyTorch : Deep learning et intelligence artificielle
• Apache Spark : Traitement de gros volumes de données
• SQL : Compétence essentielle pour l'accès aux données

Conclusion

Python s'est imposé comme l'outil de référence en data science grâce à sa simplicité et la richesse de son écosystème. Maîtriser NumPy, Pandas, Matplotlib et Scikit-learn vous donne les bases solides pour analyser et modéliser vos données efficacement.

La data science est un domaine en constante évolution qui offre d'excellentes opportunités professionnelles. Que vous souhaitiez devenir data analyst, data scientist ou machine learning engineer, Python est votre allié de choix.