Pandas : Votre allié data dans l’entreprise moderne

pip install pandas

import numpy as np # pip install numpy
import matplotlib.pyplot as plt # pip install matplotlib
import seaborn as sns # pip install seaborn

import pandas as pd
import numpy as np

ventes_jour = pd.Series([1200, 1500, 900, 1800, 2100], 
                        index=['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi'])

print(ventes_jour)
print("\nVentes du jeudi :", ventes_jour['Jeudi'])
print("\nStatistiques des ventes :")
print(f"Moyenne : {ventes_jour.mean()}")
print(f"Maximum : {ventes_jour.max()}")
print(f"Minimum : {ventes_jour.min()}")

print("\nJours avec plus de 1500€ de ventes :")
print(ventes_jour[ventes_jour > 1500])

import pandas as pd

data = {
    'Produit': ['Ordinateur', 'Écran', 'Clavier', 'Souris', 'Webcam'],
    'Prix': [1200, 350, 80, 45, 95],
    'Stock': [15, 23, 45, 60, 30],
    'Ventes_Janvier': [10, 15, 20, 25, 12],
    'Ventes_Février': [12, 18, 15, 30, 20]
}

ventes_df = pd.DataFrame(data)
print(ventes_df)

ventes_df['CA_Janvier'] = ventes_df['Prix'] * ventes_df['Ventes_Janvier']
print("\nAvec le chiffre d'affaires :")
print(ventes_df)

print("\nStatistiques des prix :")
print(ventes_df['Prix'].describe())

# Depuis un CSV
    ventes_df = pd.read_csv('ventes_2023.csv')

# Depuis un fichier Excel (nécessite openpyxl)
    ventes_df = pd.read_excel('rapport_financier.xlsx', sheet_name='Ventes')

# Depuis une base de données SQL (exemple avec SQLite)
    import sqlite3
    conn = sqlite3.connect('database.db')
    ventes_df = pd.read_sql_query("SELECT * FROM ventes", conn)

from io import StringIO
csv_data = """date,produit,quantité,prix_unitaire
2023-01-15,Ordinateur,5,1200
2023-01-15,Écran,8,350
2023-01-16,Clavier,12,80
2023-01-16,Souris,15,45
2023-01-17,Webcam,6,95
2023-01-17,Ordinateur,3,1200
2023-01-18,Écran,5,350
"""
ventes_df = pd.read_csv(StringIO(csv_data))
print(ventes_df)

ventes_df['date'] = pd.to_datetime(ventes_df['date'])
print("\nTypes des colonnes :")
print(ventes_df.dtypes)

ventes_df.to_csv('ventes_traitées.csv', index=False)
ventes_df.to_excel('rapport_ventes.xlsx', sheet_name='Données', index=False) # pip install openpyxl

import pandas as pd
import numpy as np


data = {
    'Client': ['Martin SA', 'Dupont SARL', 'Tech Solutions', 'Martin SA', np.nan],
    'Produit': ['Ordinateur', 'Écran', np.nan, 'Ordinateur', 'Clavier'],
    'Quantité': [5, 8, 12, '3', -1],
    'Prix': ['1200€', '350€', '?', '1200€', '80€'],
    'Date': ['2023-01-15', '15/01/2023', 'inconnu', '2023-01-17', '20/01/2023']
}

df = pd.DataFrame(data)
print("Données brutes :")
print(df)

# 1. Gestion des valeurs manquantes
print("\n1. Gestion des valeurs manquantes")

# Vérifier les valeurs manquantes par colonne
print(df.isna().sum())

# Remplacer par une valeur spécifique
df['Client'].fillna('Client inconnu', inplace=True)

# Remplacer par la valeur la plus fréquente (mode)
df['Produit'].fillna(df['Produit'].mode()[0], inplace=True)

print("\n2. Standardisation des types de données")

# Nettoyer la colonne Prix (supprimer le symbole € et convertir en numérique)
df['Prix'] = df['Prix'].str.replace('€', '').replace('?', np.nan)
df['Prix'] = pd.to_numeric(df['Prix'], errors='coerce')

# Convertir la colonne Quantité en entiers
df['Quantité'] = pd.to_numeric(df['Quantité'], errors='coerce')

# Corriger les valeurs négatives
df.loc[df['Quantité'] < 0, 'Quantité'] = 0

print("\n3. Standardisation des dates")
# Fonction pour convertir différents formats de date
def parse_date(date_str):
    if pd.isna(date_str) or date_str == 'inconnu':
        return pd.NaT
    try:
        return pd.to_datetime(date_str, errors='raise')
    except:
        try:
            return pd.to_datetime(date_str, format='%d/%m/%Y', errors='raise')
        except:
            return pd.NaT

df['Date'] = df['Date'].apply(parse_date)

print("\n4. Suppression des doublons")
df_clean = df.drop_duplicates()

# Données nettoyées
print("\nDonnées après nettoyage :")
print(df_clean)
print("\nTypes de données après nettoyage :")
print(df_clean.dtypes)

print("\n5. Statistiques après nettoyage :")
print(df_clean.describe())

import pandas as pd
import numpy as np

# Création d'un jeu de données de ventes plus réaliste
np.random.seed(42)  # Pour la reproductibilité

# Générer un DataFrame de 100 ventes
n = 100
produits = ['Ordinateur', 'Écran', 'Clavier', 'Souris', 'Webcam', 'Imprimante', 'Disque dur']
clients = ['Martin SA', 'Dupont SARL', 'Tech Solutions', 'InfoPro', 'DigiCorp']
regions = ['Nord', 'Sud', 'Est', 'Ouest', 'Centre']
commerciaux = ['Alice', 'Bob', 'Claire', 'David', 'Emma']

data = {
    'Date': pd.date_range(start='2023-01-01', periods=n),
    'Produit': np.random.choice(produits, n),
    'Client': np.random.choice(clients, n),
    'Region': np.random.choice(regions, n),
    'Commercial': np.random.choice(commerciaux, n),
    'Quantité': np.random.randint(1, 20, n),
    'Prix_unitaire': np.random.choice([1200, 350, 80, 45, 95, 250, 120], n)
}

ventes_df = pd.DataFrame(data)
ventes_df['CA'] = ventes_df['Quantité'] * ventes_df['Prix_unitaire']

print("Aperçu du jeu de données :")
print(ventes_df.head())

print("\n1. Sélection et filtrage des données")

# Sélectionner uniquement certaines colonnes
print("\nVentes par région et produit :")
print(ventes_df[['Date', 'Region', 'Produit', 'Quantité', 'CA']].head())

# Filtrer les ventes importantes (plus de 5 unités)
grosses_ventes = ventes_df[ventes_df['Quantité'] > 5]
print(f"\nVentes importantes (> 5 unités) : {len(grosses_ventes)} lignes")
print(grosses_ventes.head())

# Filtres combinés (ventes d'ordinateurs dans la région Nord)
ventes_ordi_nord = ventes_df[(ventes_df['Produit'] == 'Ordinateur') & (ventes_df['Region'] == 'Nord')]
print(f"\nVentes d'ordinateurs dans la région Nord : {len(ventes_ordi_nord)} lignes")
print(ventes_ordi_nord.head())

print("\n2. Création de nouvelles colonnes")

# Ajouter le mois et le trimestre
ventes_df['Mois'] = ventes_df['Date'].dt.month_name()
ventes_df['Trimestre'] = 'T' + ventes_df['Date'].dt.quarter.astype(str)

# Catégoriser les ventes
ventes_df['Catégorie'] = pd.cut(ventes_df['CA'], 
                              bins=[0, 1000, 5000, float('inf')],
                              labels=['Petite', 'Moyenne', 'Grande'])
print(ventes_df[['Date', 'Mois', 'Trimestre', 'CA', 'Catégorie']].head())

print("\n3. Agrégation et groupement")

# CA total par produit
ca_par_produit = ventes_df.groupby('Produit')['CA'].sum().sort_values(ascending=False)
print("\nChiffre d'affaires par produit :")
print(ca_par_produit)

# Multiples agrégations
stats_par_region = ventes_df.groupby('Region').agg({
    'CA': ['sum', 'mean', 'count'],
    'Quantité': ['sum', 'mean', 'max']
})
print("\nStatistiques par région :")
print(stats_par_region)

# Agrégation hiérarchique (par région puis par produit)
ca_region_produit = ventes_df.groupby(['Region', 'Produit'])['CA'].sum().unstack(fill_value=0)
print("\nCA par région et par produit :")
print(ca_region_produit)

print("\n4. Croisement et pivotement de données")

# Table croisée dynamique (équivalent d'un tableau croisé dynamique Excel)
tableau_croise = pd.pivot_table(ventes_df, 
                               values='CA', 
                               index=['Region', 'Commercial'], 
                               columns=['Mois'],
                               aggfunc='sum', 
                               fill_value=0)
print("\nTableau croisé des ventes par région, commercial et mois :")
print(tableau_croise.head(10))

print("\n5. Fusion de DataFrames")

# Créer un DataFrame des objectifs de vente par commercial
objectifs = pd.DataFrame({
    'Commercial': commerciaux,
    'Objectif_Mensuel': [50000, 45000, 55000, 40000, 60000]
})
print("\nObjectifs de vente par commercial :")
print(objectifs)

# Calculer les ventes réelles par commercial
ventes_par_commercial = ventes_df.groupby('Commercial')['CA'].sum().reset_index()
ventes_par_commercial.rename(columns={'CA': 'Ventes_Réelles'}, inplace=True)
print("\nVentes réelles par commercial :")
print(ventes_par_commercial)

# Fusionner les deux DataFrames
comparaison = pd.merge(objectifs, ventes_par_commercial, on='Commercial')
comparaison['Performance'] = comparaison['Ventes_Réelles'] / comparaison['Objectif_Mensuel'] * 100
print("\nComparaison objectifs vs réalisation :")
print(comparaison)

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Utilisons les données générées précédemment
# (supposant que le code précédent a été exécuté)

# Configuration pour de meilleurs visuels
plt.style.use('ggplot')
plt.rcParams.update({'font.size': 12})

print("1. Analyse temporelle des ventes")

# Regrouper par mois
ventes_mensuelles = ventes_df.groupby(ventes_df['Date'].dt.strftime('%Y-%m'))['CA'].sum()
print(ventes_mensuelles)

# Visualisation des ventes mensuelles
plt.figure(figsize=(10, 6))
ventes_mensuelles.plot(kind='bar', color='skyblue')
plt.title('Évolution des ventes mensuelles')
plt.xlabel('Mois')
plt.ylabel('Chiffre d\'affaires (€)')
plt.xticks(rotation=45)
plt.tight_layout()
# plt.savefig('ventes_mensuelles.png')
# plt.show()

print("\n2. Analyse des performances par produit")

# Top 3 des produits les plus vendus (en quantité)
top_produits_quantite = ventes_df.groupby('Produit')['Quantité'].sum().sort_values(ascending=False).head(3)
print("\nTop 3 des produits les plus vendus (en quantité) :")
print(top_produits_quantite)

# Top 3 des produits les plus rentables (en CA)
top_produits_ca = ventes_df.groupby('Produit')['CA'].sum().sort_values(ascending=False).head(3)
print("\nTop 3 des produits les plus rentables (en CA) :")
print(top_produits_ca)

# Visualisation
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
top_produits_quantite.plot(kind='pie', autopct='%1.1f%%')
plt.title('Répartition des quantités vendues (Top 3)')
plt.ylabel('')

plt.subplot(1, 2, 2)
top_produits_ca.plot(kind='pie', autopct='%1.1f%%')
plt.title('Répartition du CA (Top 3)')
plt.ylabel('')
plt.tight_layout()
# plt.savefig('analyse_produits.png')
# plt.show()

print("\n3. Analyse des performances par région")

perf_regions = ventes_df.groupby('Region')['CA'].agg(['sum', 'mean', 'count'])
perf_regions.columns = ['CA Total', 'Panier Moyen', 'Nombre de Ventes']
perf_regions.sort_values('CA Total', ascending=False, inplace=True)
print(perf_regions)

# Visualisation du CA par région
plt.figure(figsize=(10, 6))
perf_regions['CA Total'].plot(kind='barh', color='green')
plt.title('Chiffre d\'affaires par région')
plt.xlabel('Chiffre d\'affaires (€)')
plt.ylabel('Région')
plt.tight_layout()
# plt.savefig('ca_par_region.png')
# plt.show()

print("\n4. Analyse des performances des commerciaux")

# Performance globale par commercial
perf_commerciaux = ventes_df.groupby('Commercial').agg({
    'CA': 'sum',
    'Client': 'nunique',  # Nombre de clients uniques
    'Quantité': 'sum'
})
perf_commerciaux.columns = ['CA Total', 'Nombre de Clients', 'Quantité Totale']
perf_commerciaux['Panier Moyen'] = perf_commerciaux['CA Total'] / perf_commerciaux['Nombre de Clients']
perf_commerciaux.sort_values('CA Total', ascending=False, inplace=True)
print(perf_commerciaux)

print("\n5. Analyse croisée produits/régions")

analyse_croisee = pd.crosstab(index=ventes_df['Produit'], 
                              columns=ventes_df['Region'], 
                              values=ventes_df['CA'], 
                              aggfunc='sum',
                              normalize='columns',  # % par colonne
                              margins=True)  # Ajoute une ligne et une colonne de totaux
print("\nRépartition des produits par région (en % du CA) :")
print(analyse_croisee)

# Heatmap pour visualiser la répartition
plt.figure(figsize=(12, 8))
# On exclut la ligne et la colonne 'All' (totaux)
heatmap_data = analyse_croisee.iloc[:-1, :-1]
plt.imshow(heatmap_data, cmap='YlGnBu')
plt.colorbar(label='% du CA de la région')
plt.xticks(range(len(heatmap_data.columns)), heatmap_data.columns, rotation=45)
plt.yticks(range(len(heatmap_data.index)), heatmap_data.index)
plt.title('Répartition des ventes par produit et région')

# Ajouter les valeurs dans les cellules
for i in range(len(heatmap_data.index)):
    for j in range(len(heatmap_data.columns)):
        plt.text(j, i, f"{heatmap_data.iloc[i, j]:.1%}", 
                 ha="center", va="center", color="black" if heatmap_data.iloc[i, j] < 0.3 else "white")

plt.tight_layout()
# plt.savefig('heatmap_produits_regions.png')
# plt.show()

print("\n6. Analyse de corrélation")

# Corrélation entre quantité et CA par produit
corr_data = ventes_df.groupby('Produit').agg({
    'Quantité': 'sum',
    'CA': 'sum'
})
print("\nCorrélation entre quantité vendue et CA par produit :")
print(corr_data.corr())

# Visualisation scatter plot
plt.figure(figsize=(8, 6))
plt.scatter(corr_data['Quantité'], corr_data['CA'], s=100, alpha=0.7)
for i, txt in enumerate(corr_data.index):
    plt.annotate(txt, (corr_data['Quantité'].iloc[i], corr_data['CA'].iloc[i]), 
                 xytext=(5, 5), textcoords='offset points')
plt.title('Relation entre quantité vendue et CA par produit')
plt.xlabel('Quantité vendue')
plt.ylabel('Chiffre d\'affaires (€)')
plt.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()
# plt.savefig('correlation_quantite_ca.png')
# plt.show()

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime
import os

# Fonction pour générer un rapport complet
def generer_rapport_ventes(df, periode='mensuel', dossier_sortie='rapports'):
    """
    Génère un rapport de ventes basé sur un DataFrame Pandas
    
    Args:
        df: DataFrame Pandas contenant les données de ventes
        periode: 'mensuel' ou 'trimestriel'
        dossier_sortie: Dossier où enregistrer les rapports générés
    """
    # Créer le dossier de sortie si nécessaire
    if not os.path.exists(dossier_sortie):
        os.makedirs(dossier_sortie)
    
    # Définir la période d'analyse
    if periode == 'mensuel':
        df['Periode'] = df['Date'].dt.strftime('%Y-%m')
        titre_periode = "mensuel"
    else:
        df['Periode'] = df['Date'].dt.year.astype(str) + '-T' + df['Date'].dt.quarter.astype(str)
        titre_periode = "trimestriel"
    
    # Date du rapport
    date_rapport = datetime.now().strftime('%Y-%m-%d')
    
    # 1. Résumé des ventes par période
    resume_periodes = df.groupby('Periode').agg({
        'CA': 'sum',
        'Quantité': 'sum',
        'Client': 'nunique'
    })
    resume_periodes.columns = ['CA Total', 'Quantité Totale', 'Nombre de Clients']
    
    # 2. Top produits par période
    top_produits = df.pivot_table(
        values='CA', 
        index='Produit',
        columns='Periode',
        aggfunc='sum',
        fill_value=0
    ).sort_values(by=df['Periode'].max(), ascending=False)
    
    # 3. Performance des commerciaux
    perf_commerciaux = df.pivot_table(
        values='CA',
        index='Commercial',
        columns='Periode',
        aggfunc='sum',
        fill_value=0
    ).sort_values(by=df['Periode'].max(), ascending=False)
    
    # 4. Ventes par région
    ventes_regions = df.pivot_table(
        values='CA',
        index='Region',
        columns='Periode',
        aggfunc='sum',
        fill_value=0
    )
    
    # 5. Créer le rapport Excel
    nom_fichier = f"{dossier_sortie}/rapport_ventes_{titre_periode}_{date_rapport}.xlsx"
    
    with pd.ExcelWriter(nom_fichier, engine='xlsxwriter') as writer:
        # Feuille de résumé
        resume_periodes.to_excel(writer, sheet_name='Résumé')
        workbook = writer.book
        worksheet = writer.sheets['Résumé']
        
        # Ajouter un graphique
        chart = workbook.add_chart({'type': 'column'})
        for i in range(len(resume_periodes)):
            chart.add_series({
                'name':       f'=Résumé!$B$1',
                'categories': f'=Résumé!$A$2:$A${len(resume_periodes)+1}',
                'values':     f'=Résumé!$B$2:$B${len(resume_periodes)+1}',
            })
        
        chart.set_title({'name': f'Évolution du CA {titre_periode}'})
        chart.set_x_axis({'name': 'Période'})
        chart.set_y_axis({'name': 'Chiffre d\'affaires (€)'})
        worksheet.insert_chart('E2', chart, {'x_scale': 1.5, 'y_scale': 1.5})
        
        # Autres feuilles
        top_produits.to_excel(writer, sheet_name='Top Produits')
        perf_commerciaux.to_excel(writer, sheet_name='Commerciaux')
        ventes_regions.to_excel(writer, sheet_name='Régions')
        
        # Mise en forme conditionnelle pour les performances
        worksheet_comm = writer.sheets['Commerciaux']
        format_bon = workbook.add_format({'bg_color': '#C6EFCE', 'font_color': '#006100'})
        format_moyen = workbook.add_format({'bg_color': '#FFEB9C', 'font_color': '#9C5700'})
        format_mauvais = workbook.add_format({'bg_color': '#FFC7CE', 'font_color': '#9C0006'})
        
        # Dernière colonne (performance actuelle)
        derniere_col = len(perf_commerciaux.columns) + 1
        worksheet_comm.conditional_format(1, derniere_col, len(perf_commerciaux)+1, derniere_col, {
            'type': '3_color_scale',
            'min_color': "#FFC7CE",
            'mid_color': "#FFEB9C",
            'max_color': "#C6EFCE"
        })
    
    print(f"Rapport généré avec succès: {nom_fichier}")
    return nom_fichier

# Exemple d'utilisation (avec les données générées précédemment)
# rapport_genere = generer_rapport_ventes(ventes_df, periode='mensuel')
print("Fonction pour générer automatiquement des rapports Excel avec pandas ✓")

# Exemple de planning d'automatisation de rapports
print("\nPlanification des rapports automatiques avec Python")
print("--------------------------------------------------")
print("1. Rapport des ventes quotidien → Tous les matins à 7h")
print("2. Rapport hebdomadaire des performances commerciales → Chaque lundi à 8h")
print("3. Tableau de bord mensuel pour la direction → Le 1er du mois à 9h")
print("4. Analyse trimestrielle complète → Dans les 5 jours suivant la fin du trimestre")
print("\nCes rapports peuvent être automatisés en combinant pandas avec:")
print("- Windows: Planificateur de tâches + script Python")
print("- Linux/Mac: Cron + script Python")
print("- Serveur: Airflow, Luigi ou frameworks similaires")