Fiche Python - Pandas

Complete et pratique pour les plus determinés

Prerequis Python
Installation et environnement
Structures fondamentales Pandas
Lecture et ecriture des donnees
Inspection et comprehension des donnees
Selection et indexing
Nettoyage des donnees
Operations vectorisees
Fonctions essentielles
Statistiques et aggregations
GroupBy avance
Merge / Join / Concat
Time Series finance
Visualisation rapide
Verifications et assertions
Bonnes pratiques professionnelles
PROJET COMPLET
Un mot pour les plus motivés

Ghali Mikou

Document pedagogique
Pour gerer ses entretiens même si ça sert a rien de savoir coder de nos jours en finance, on le rappelle

February 16, 2026

0. Avant Pandas : prerequis minimaux Python

Objectif : maitriser les bases indispensables de Python avant d utiliser Pandas pour l analyse de
donnees. Si ces bases ne sont pas acquises, Pandas deviendra difficile a comprendre.

Tu dois savoir :

• Variables et types (int, float, str, bool)

• Listes, tuples, dictionnaires

• Boucles for et conditions if

• Fonctions

• Import de modules

1) Variables et types
Variables et types de base

# On definit des variables avec des types differents

price = 152.3 # float : prix de marche

quantity = 10 # int : nombre de titres
ticker = " AAPL " # str : identifiant de l action
active = True # bool : indicateur logique

# La fonction type () permet de verifier le type d une variable

print ( type ( price ) )

print ( type ( quantity ) )
print ( type ( ticker ) )
print ( type ( active ) )

Points cles :

• Python est dynamiquement type, le type depend de la valeur.

• En cas d erreur de calcul, toujours verifier les types.

Par mes soins - Ghali Mikou Page 2/29

2) Listes, tuples, dictionnaires
Structures de donnees principales

# Une liste est une structure modifiable

# Cas typique : serie de prix

prices = [150.2 , 151.0 , 152.3]

prices . append (153.1)

# Un tuple est une structure non modifiable

# Cas typique : parametres fixes

returns = (0.01 , -0.02 , 0.015)

# Un dictionnaire associe des cles a des valeurs

# Cas typique : description d un actif financier

stock = {
" ticker " : " AAPL " ,
" price " : 152.3 ,
" currency " : " USD "
}

# Acces et affichage des donnees

print ( prices )
print ( returns )
print ( stock [ " ticker " ] , stock [ " price " ])

Intuition finance :

• Liste → serie temporelle de prix ou rendements

• Dictionnaire → informations descriptives d un actif

3) Boucles et conditions
Boucle for avec condition

# On parcourt une liste de prix

prices = [150 , 152 , 149 , 155]

for p in prices :

# On teste si le prix est superieur a 150

if p > 150:
print (p , " prix eleve " )

else :
print (p , " prix faible " )

Erreur courante : comparer une chaine de caracteres et un nombre.

Par mes soins - Ghali Mikou Page 3/29

4) Fonctions
Fonction de calcul du rendement

# Cette fonction calcule un rendement simple

# rendement = ( prix_final / prix_initial ) - 1

def return_rate ( initial_price , final_price ) :

return ( final_price / initial_price ) - 1

# Appel de la fonction avec des valeurs d exemple

r = return_rate (150 , 155)

print ( r )

Lien avec Pandas :

• Pandas applique ces fonctions a des colonnes entieres.

• Comprendre le calcul sur une valeur est fondamental.

5) Import de modules
Import de modules Python

# Import de modules standards

import math
import random

# Utilisation des fonctions importees

x = math . sqrt (16) # racine c a r r e

y = random . random () # Nombre a l a t o i r e

print (x , y )

Imports classiques avec Pandas (Indispensables en début de code):

import pandas as pd
import numpy as np

Mini exercices (enonces)

1. Creer les variables ticker = "MSFT" et price = 410.5 puis afficher leur type.

2. Creer une liste de cinq prix et afficher uniquement ceux strictement superieurs a 100.

3. Ecrire une fonction return_rate(p0, p1) et la tester sur (100, 105).

4. Creer un dictionnaire stock avec ticker, price et currency puis afficher ticker et currency.

Par mes soins - Ghali Mikou Page 4/29

Corrections
Exercice 1

ticker = " MSFT "

price = 410.5

print ( type ( ticker ) )

print ( type ( price ) )

Exercice 2

prices = [95 , 102 , 110 , 98 , 120]

for p in prices :
if p > 100:
print ( p )

Exercice 3

def return_rate ( p0 , p1 ) :
return ( p1 / p0 ) - 1

print ( return_rate (100 , 105) )

Exercice 4

stock = {
" ticker " : " MSFT " ,
" price " : 410.5 ,
" currency " : " USD "
}

print ( stock [ " ticker " ] , stock [ " currency " ])

On sait jamais : Si ces bases sont solides, vous êtes prêts pour manipuler Pandas. Soyez curieux
pour le reste (ça peut toujours aider pour des cas un peu niche)

Par mes soins - Ghali Mikou Page 5/29

1. Installation et environnement de travail
Librairies indispensables :

• pandas : manipulation de donnees tabulaires

• numpy : calcul numerique

• matplotlib : visualisation

• openpyxl : lecture et ecriture de fichiers Excel

Installation des librairies

Installation via pip

# Cette commande installe les librairies principales

# Elle doit etre executee dans le terminal , a lancer une seule fois .

pip install pandas numpy matplotlib openpyxl

Imports standards (reflexe a adopter)

Imports standards Pandas

# Convention universelle dans les projets data , comme dit precedemment

import pandas as pd
import numpy as np

Petits tips teh les fous:

• Toujours utiliser un environnement virtuel (venv).

• Ne jamais installer pandas globalement pour tous les projets.

• Verifier la version de Python avant installation, ca vous evitera de vous acharner sur ChatGPT
parce que votre code ne compile pas.

IDE que je recommande:

• VS Code : leger, flexible, tout simplement le goat, ideal pour Pandas.

• Jupyter Notebook : parfait pour exploration rapide.

• PyCharm : adapte aux projets de grande taille.

Par mes soins - Ghali Mikou Page 6/29

2. Structures fondamentales Pandas
Objectif : comprendre les deux structures de base de Pandas : Series et DataFrame. Toutes les
manipulations Pandas reposent sur ces objets.

2.1 Series
Definition : Une Series est un tableau 1D indexe. Chaque valeur est associee a un index.
Creation d une Series

# Creation d une Series a partir d une liste

# Chaque valeur est associee a un index explicite

s = pd . Series (
[10 , 20 , 30] ,
index =[ " a " , " b " , " c " ]
)

# Affichage de la Series
print ( s )

A comprendre :

• Une Series contient toujours des valeurs ET un index.

• L index permet d identifier chaque valeur.

Acces aux valeurs

Acces par index

# Acces a une valeur via le label de l index

print ( s [ " a " ])

print ( s [ " b " ])

Valeurs manquantes (NaN)

Presence de NaN dans une Series

# Une Series peut contenir des valeurs manquantes

# None est automatiquement converti en NaN

s_nan = pd . Series ([10 , None , 30])

# Affichage de la Series avec NaN

print ( s_nan )

Operations vectorisees
Operations sur une Series

# Les operations sont appliquees a toutes les valeurs

# Aucune boucle explicite n est necessaire

s_mult = s * 2
s_add = s + 5

print ( s_mult )
print ( s_add )

Par mes soins - Ghali Mikou Page 7/29

2.2 DataFrame
Definition : Un DataFrame est un tableau 2D compose de lignes et de colonnes. Chaque colonne est
une Series.
Creation d un DataFrame

# Creation d un DataFrame a partir d un dictionnaire

# Chaque cle du dictionnaire devient une colonne

df = pd . DataFrame ({
" price " : [10 , 12 , 9] ,
" volume " : [100 , 200 , 150]
})

# Affichage du DataFrame
print ( df )

Lecture :

• Chaque ligne correspond a une observation.

• Chaque colonne correspond a une variable.

Index et colonnes
Structure interne du DataFrame

# L index identifie les lignes

# Les colonnes identifient les variables

print ( df . index )
print ( df . columns )

Colonnes comme Series

Extraction d une colonne

# Une colonne extraite est une Series Pandas

price_series = df [ " price " ]

print ( price_series )
print ( type ( price_series ) )

Conclusion intermediaire :

• DataFrame = ensemble de Series partageant le meme index.

Mini exercices (enonces)

1. Creer une Series avec les valeurs [5, 10, 15] et les index ["x", "y", "z"].

2. Afficher uniquement la valeur associee a l index "y".

3. Multiplier toute la Series par 3.

4. Creer un DataFrame avec deux colonnes : return = [0.01, -0.02, 0.03] et volatility = [0.2,
0.25, 0.22].

5. Extraire la colonne return et verifier son type.

Par mes soins - Ghali Mikou Page 8/29

Corrections
Exercice 1

s = pd . Series (
[5 , 10 , 15] ,
index =[ " x " , " y " , " z " ]
)

print ( s )

Exercice 2

print ( s [ " y " ])

Exercice 3

print ( s * 3)

Exercice 4

df = pd . DataFrame ({
" return " : [0.01 , -0.02 , 0.03] ,
" volatility " : [0.2 , 0.25 , 0.22]
})

print ( df )

Exercice 5

ret_series = df [ " return " ]

print ( ret_series )
print ( type ( ret_series ) )

Par mes soins - Ghali Mikou Page 9/29

3. Lire et ecrire des donnees (ULTRA IMPORTANT)

3.1 Lecture de donnees

Fonctions principales :
• pd.read_csv() : fichiers CSV

• pd.read_excel() : fichiers Excel

• pd.read_json() : fichiers JSON

Lecture simple de fichiers

# Lecture d un fichier CSV standard

df_csv = pd . read_csv ( " file . csv " )

# Lecture d un fichier Excel

df_excel = pd . read_excel ( " file . xlsx " , sheet_name = " Sheet1 " )

# Lecture d un fichier JSON

df_json = pd . read_json ( " file . json " )

Parametres critiques (pieges frequents)

• sep : separateur de colonnes

• decimal : separateur decimal

• encoding : encodage du fichier

• dtype : type force des colonnes

• parse_dates : conversion automatique des dates

Lecture avec parametres explicites

# Exemple typique de fichier europeen

# Colonnes separees par ;
# Virgule utilisee comme separateur decimal
# Colonne date a convertir automatiquement

df = pd . read_csv ( " data . csv " , sep = " ; " , decimal = " ," , parse_dates =[ " date " ])

# Verification rapide du resultat

print ( df . head () )
print ( df . dtypes )

Points d attention :
• Sans sep correct, Pandas lit tout dans une seule colonne. Sans parse_dates, les dates sont lues
comme du texte.
Forcer les types avec dtype
Forcer les types de colonnes

# Forcer les types pour eviter les erreurs silencieuses

df = pd . read_csv ( " data . csv " , sep = " ; " , dtype ={ " price " : float , " volume " : int })

print ( df . dtypes )

Par mes soins - Ghali Mikou Page 10/29

3.2 Ecriture de donnees
Fonctions principales :

• df.to_csv() : exporter son dataframe dans un fichier CSV

• df.to_excel() : exporter sur Excel

Ecriture vers CSV et Excel

# index = False evite d ecrire l index dans le fichier

df . to_csv ( " out . csv " , index = False )

df . to_excel ( " out . xlsx " , index = False )

Mini exercices (enonces)

1. Lire un fichier CSV separe par des ; avec une colonne date.

2. Verifier les types des colonnes apres lecture.

3. Forcer le type float pour une colonne price.

4. Exporter le DataFrame vers un fichier CSV sans index.

Corrections

df = pd . read_csv (
" data . csv " ,
sep = " ; " ,
parse_dates =[ " date " ]
)

print ( df . head () )
print ( df . dtypes )

df = pd . read_csv (
" data . csv " ,
sep = " ; " ,
dtype ={ " price " : float }
)

print ( df . dtypes )
df . to_csv ( " output . csv " , index = False )

Par mes soins - Ghali Mikou Page 11/29

4. Inspection et comprehension des donnees

Objectif : comprendre rapidement la structure et le contenu d un DataFrame. Ces commandes doivent

devenir des reflexes automatiques avant toute manipulation.
Commandes essentielles

• [Link]() : afficher les premieres lignes

• [Link]() : afficher les dernieres lignes

• [Link]() : structure generale et types

• [Link]() : statistiques descriptives

• [Link] : dimensions du DataFrame

• [Link] : noms des colonnes

• [Link] : types des colonnes

Inspection rapide d un DataFrame

# Affiche les 5 premieres lignes

print ( df . head () )

# Affiche les 5 premieres lignes

print ( df . head (10) )

# Affiche les 5 dernieres lignes

print ( df . tail () )

# Affiche les 10 dernieres lignes

print ( df . tail (10) )

# Nombre de lignes , colonnes , types , valeurs manquantes ( infos generales )

print ( df . info () )

# Statistiques descriptives sur les colonnes numeriques

print ( df . describe () )

# Dimensions du DataFrame ( lignes , colonnes )

print ( df . shape )

# Liste des noms de colonnes

print ( df . columns )

# Types de chaque colonne

print ( df . dtypes )

Par mes soins - Ghali Mikou Page 12/29

5. Selection et indexing (CRUCIAL)

Objectif : savoir selectionner correctement des donnees dans un DataFrame.

5.1 Selection simple de colonnes
Selection de colonnes

# Selection d une seule colonne

# Le resultat est une Series

price = df [ " price " ]

print ( price )

# Selection de plusieurs colonnes

# Le resultat est un DataFrame

subset = df [[ " price " , " volume " ]]

print ( subset )

5.2 Selection avec loc (par labels)

Principe : loc selectionne par labels d index et noms de colonnes.
Selection avec loc

# Selection d une valeur precise par label de ligne et colonne

# Ici , 0 est le label de l index , pas la position

value = df . loc [0 , " price " ]

print ( value )

# Selection de toutes les lignes et de colonnes choisies

subset_loc = df . loc [: , [ " price " , " volume " ]]
print ( subset_loc )

5.3 Selection avec iloc (par positions)

Principe : iloc selectionne par positions numeriques (comme en Python).
Selection avec iloc

# Selection par position ( ligne 0 , colonne 1)

value = df . iloc [0 , 1]
print ( value )

# Selection des 5 premieres lignes et de toutes les colonnes

subset_iloc = df . iloc [:5 , :]
print ( subset_iloc )

5.4 Filtrage logique

Principe : On filtre les lignes a partir de conditions booleennes.

Par mes soins - Ghali Mikou Page 13/29

 Filtrage simple

# Filtrage sur une condition simple , ici on renvoie le dataframe avec des d o n n e s
telles que le prix est superieur a 10

filtered = df [ df [ " price " ] > 10]

print ( filtered )

Filtrage avec plusieurs conditions

# Filtrage avec plusieurs conditions , chaque condition doit etre entre parentheses
# Les operateurs sont & ( ET ) et | ( OU )

filtered = df [( df [ " price " ] > 10) & ( df [ " volume " ] < 200) ]

print ( filtered )

Mini exercices (enonces)

1. Selectionner uniquement la colonne price.

2. Selectionner les colonnes price et volume.

3. Recuperer la valeur price de la premiere ligne avec loc.

4. Recuperer la valeur price de la premiere ligne avec iloc.

5. Filtrer les lignes ou price est strictement superieur a 10.

6. Filtrer les lignes ou price > 10 et volume < 200.

Corrections

price = df [ " price " ]

print ( price )

subset = df [[ " price " , " volume " ]]

print ( subset )

value = df . loc [0 , " price " ]

print ( value )

value = df . iloc [0 , 0]
print ( value )

filtered = df [ df [ " price " ] > 10]

print ( filtered )

filtered = df [( df [ " price " ] > 10) & ( df [ " volume " ] < 200) ]

print ( filtered )

Par mes soins - Ghali Mikou Page 14/29

6. Nettoyage des donnees (tres demande en job)

6.1 Valeurs manquantes

Principe : Les valeurs manquantes sont representees par NaN. Il faut savoir les detecter, les supprimer
ou les remplacer.
Detection des valeurs manquantes

# isna () renvoie True si la valeur est manquante

print ( df . isna () )

Suppression des lignes avec NaN

# dropna () supprime les lignes contenant au moins un NaN

df_clean = df . dropna ()

print ( df_clean )

Remplacement des NaN par une valeur fixe

# fillna (0) remplace toutes les valeurs manquantes par 0

df_filled = df . fillna (0)

print ( df_filled )

Remplacement par une statistique

# Remplacer les NaN de la colonne price par la moyenne

df [ " price " ] = df [ " price " ]. fillna ( df [ " price " ]. mean () )

print ( df )

6.2 Doublons
Principe : Les doublons faussent les statistiques et les analyses.
Detection des doublons

# duplicated () renvoie True pour les lignes dupliquees

print ( df . duplicated () )

Suppression des doublons

# drop_duplicates () supprime les lignes dupliquees

df_unique = df . drop_duplicates ()

print ( df_unique )

Par mes soins - Ghali Mikou Page 15/29

6.3 Conversion des types
Conversion explicite des types

# Conversion d une colonne en float

df [ " price " ] = df [ " price " ]. astype ( float )

# Conversion d une colonne en datetime

df [ " date " ] = pd . to_datetime ( df [ " date " ])

print ( df . dtypes )

Mini exercices (enonces)

1. Detecter les valeurs manquantes dans un DataFrame.

2. Supprimer les lignes contenant des valeurs manquantes.

3. Remplacer les NaN d une colonne amount par sa moyenne.

4. Detecter puis supprimer les lignes dupliquees.

5. Convertir une colonne quantity en int et une colonne traded ateendatetime.

Corrections

print ( data . isna () )

data_clean = data . dropna ()

data [ " amount " ] = data [ " amount " ]. fillna ( data [ " amount " ]. mean () )

print ( data )

data_unique = data . drop_duplicates ()

data [ " quantity " ] = data [ " quantity " ]. astype ( int )
data [ " trade_date " ] = pd . to_datetime ( data [ " trade_date " ])

print ( data . dtypes )

Par mes soins - Ghali Mikou Page 16/29

7. Operations vectorisees (ADN Pandas)

Objectif : comprendre pourquoi Pandas doit etre utilise de maniere vectorisee. Boucler ligne par ligne
est presque toujours une erreur.
Mauvaise pratique (lente)
Boucle explicite sur les lignes

# Cette approche parcourt le DataFrame ligne par ligne

# Elle est lente et ne doit presque jamais etre utilisee

for i in range ( len ( df ) ) :

df . loc [i , " x " ] = df . loc [i , " a " ] + df . loc [i , " b " ]

Le souci mon ami :

• Execution lente sur des grands volumes.

• Code difficile a lire et a maintenir.

Bonne pratique (vectorisee)

Operation vectorisee

# L operation est appliquee a toute la colonne d un coup

# Pandas travaille en interne de maniere optimisee

df [ " x " ] = df [ " a " ] + df [ " b " ]

Dooooooonc en gros:

• Toujours penser colonne avant ligne.

• Si tu ecris une boucle for sur df, c est souvent un signal d alerte.

Par mes soins - Ghali Mikou Page 17/29

8. Fonctions essentielles Pandas
Objectif : comprendre quand et comment utiliser apply(), map() et applymap(). Ces fonctions sont
puissantes mais doivent etre utilisees avec discernement.
Vue d ensemble

Fonction Usage
apply() Appliquer une fonction sur une Series ou par ligne
map() Transformer une Series valeur par valeur
applymap() Appliquer une fonction a toutes les cellules d un DataFrame

apply() sur une Series

Utilisation de apply sur une colonne

# apply applique une fonction Python a chaque valeur

# La fonction peut etre une lambda ou une fonction definie

df [ " price_eur " ] = df [ " price_usd " ]. apply ( lambda x : x * 0.92)

print ( df [[ " price_usd " , " price_eur " ]])

map() sur une Series

Transformation avec map

# map transforme chaque valeur d une Series

currency_map = {
" USD " : " US Dollar " ,
" EUR " : " Euro "
}

df [ " currency_name " ] = df [ " currency " ]. map ( currency_map )

# en gros ici ca va parcourir la colonne currency et si ca trouve " EUR " par
exemple , ca va stocker " Euro " dans la nouvelle colonne currency_name

print ( df [[ " currency " , " currency_name " ]])

apply() sur un DataFrame

apply par ligne

# axis =1 signifie que la fonction est appliquee ligne par ligne

df [ " total " ] = df . apply ( lambda row : row [ " price " ] * row [ " quantity " ] , axis =1)

print ( df [[ " price " , " quantity " , " total " ]])

Par mes soins - Ghali Mikou Page 18/29

applymap() sur un DataFrame
applymap sur tout le DataFrame

# applymap applique une fonction a chaque cellule

df_rounded = df [[ " price " ," total " ]]. applymap ( lambda x : round (x , 2) )

print ( df_rounded )

Mini exercices (enonces)

1. Creer une colonne amount_eur a partir de amount_usd avec un taux de 0.9.

2. Utiliser map pour transformer une colonne country_code en nom de pays.

3. Calculer une colonne value = price * units avec apply par ligne.

Corrections

data [ " amount_eur " ] = data [ " amount_usd " ]. apply (

lambda x : x * 0.9
)

print ( data [[ " amount_usd " , " amount_eur " ]])

country_map = {
" FR " : " France " ,
" DE " : " Germany "
}

data [ " country_name " ] = data [ " country_code " ]. map ( country_map )

print ( data [[ " country_code " , " country_name " ]])

data [ " value " ] = data . apply (

lambda row : row [ " price " ] * row [ " units " ] ,
axis =1
)

print ( data [[ " price " , " units " , " value " ]])

Par mes soins - Ghali Mikou Page 19/29

9. Statistiques et aggregations

Fonctions statistiques courantes

• mean() : moyenne

• sum() : somme

• min() : minimum

• max() : maximum

• std() : ecart type

• quantile() : quantile

Statistiques sur un DataFrame

# Calcul de la moyenne sur toutes les colonnes numeriques

print ( df . mean () )

# Somme des colonnes numeriques

print ( df . sum () )

# Valeurs minimales et maximales

print ( df . min () )
print ( df . max () )

# Ecart type des colonnes numeriques

print ( df . std () )

Calcul de quantile

# Calcul du quantile a 95 pour les colonnes numeriques

# Tres utilise en finance et en gestion du risque

print ( df . quantile (0.95) )

Par mes soins - Ghali Mikou Page 20/29

10. GroupBy (ULTRA IMPORTANT)

Principe general
Lecture mentale :

• On decoupe les donnees par groupe.

• On applique une fonction sur chaque groupe.

• On recolle les resultats.

GroupBy simple
Moyenne par groupe

# On regroupe les donnees par secteur

# Puis on calcule la moyenne du prix par secteur

mean_price = df . groupby ( " sector " ) [ " price " ]. mean ()

print ( mean_price )

GroupBy avec plusieurs aggregations

Aggregation avancee avec agg

# agg permet d appliquer plusieurs fonctions

summary = df . groupby ( " sector " ) . agg ({

" price " : " mean " ,
" volume " : " sum "
})

print ( summary )

# Ici , on calcule PAR SECTEUR la moyenne de prix et la somme de volumes

Gestion de l index avec reset

GroupBy avec reset de l index

# as_index = False permet de garder le groupe comme colonne

summary_df = df . groupby ( " sector " , as_index = False ) . mean ()

print ( summary_df )

Mini exercices (enonces)

1. Calculer la moyenne de revenue par categorie.

2. Calculer la somme de quantity par categorie.

3. Utiliser agg pour calculer la moyenne de revenue et la somme de quantity.

4. Effectuer un groupby par categorie en conservant categorie comme colonne.

Par mes soins - Ghali Mikou Page 21/29

Corrections

avg_revenue = data . groupby ( " category " ) [ " revenue " ]. mean ()

print ( avg_revenue )

sum_quantity = data . groupby ( " category " ) [ " quantity " ]. sum ()

print ( sum_quantity )

summary = data . groupby ( " category " ) . agg ({

" revenue " : " mean " ,
" quantity " : " sum "
})

print ( summary )

summary_df = data . groupby (

" category " ,
as_index = False
) . mean ()

print ( summary_df )

Par mes soins - Ghali Mikou Page 22/29

11. Merge / Join / Concat (niveau pro)

11.1 Merge (jointure type SQL)

Principe : [Link] permet de joindre deux DataFrame sur une cle commune, comme en SQL.
Merge simple sur une cle

# df1 et df2 partagent une colonne id

# how definit le type de jointure

merged_left = pd . merge ( df1 , df2 , on = " id " , how = " left " )

print ( merged_left )

Types de jointure :
• inner : lignes presentes dans les deux tables
• left : toutes les lignes de la table de gauche
• right : toutes les lignes de la table de droite
• outer : union de toutes les lignes
Exemples de types de jointure

# Jointure interne
inner_join = pd . merge ( df1 , df2 , on = " id " , how = " inner " )

# Jointure droite
right_join = pd . merge ( df1 , df2 , on = " id " , how = " right " )

# Jointure externe
outer_join = pd . merge ( df1 , df2 , on = " id " , how = " outer " )

print ( inner_join )
print ( right_join )
print ( outer_join )

11.2 Concat (empilement)

Principe : [Link] permet d empiler ou de coller des DataFrame.
Concat verticale

# axis =0 empile les lignes

# Les colonnes doivent etre compatibles

stacked = pd . concat ([ df1 , df2 ] , axis =0)

print ( stacked )

Concat horizontale

# axis =1 colle les DataFrame cote a cote

# L index est utilise pour aligner les lignes

combined = pd . concat ([ df1 , df2 ] , axis =1)

print ( combined )

Mini exercices (enonces)

Par mes soins - Ghali Mikou Page 23/29

 1. Effectuer une jointure left entre sales et products sur product_id.

2. Effectuer une jointure inner sur la meme cle.

3. Concatener deux DataFrame orders_2023 et orders_2024 en lignes.

4. Concatener deux DataFrame metrics_price et metrics_volume en colonnes.

Corrections

sales_products = pd . merge ( sales , products , on = " product_id " , how = " left " )

print ( sales_products )

s a l e s _ p r o d ucts_inner = pd . merge ( sales , products , on = " product_id " , how = " inner " )

print ( s a l e s _products_inner )

orders_all = pd . concat ([ orders_2023 , orders_2024 ] , axis =0)

print ( orders_all )

metrics = pd . concat ([ metrics_price , metrics_volume ] , axis =1)

print ( metrics )

Par mes soins - Ghali Mikou Page 24/29

13. Time Series (tres finance)

Preparation des dates

Conversion et index temporel

# Conversion explicite de la colonne date en datetime

# Indispensable avant toute operation temporelle

df [ " date " ] = pd . to_datetime ( df [ " date " ])

# Definition de la colonne date comme index

# Necessaire pour rolling et resample

df . set_index ( " date " )

print ( df . head () )

Rolling (fenetres glissantes)

Moyenne mobile

# Calcul d une moyenne mobile sur 20 periodes

df [ " ma_20 " ] = df [ " price " ]. rolling (20) . mean ()

print ( df [[ " price " , " ma_20 " ]]. head (25) )

Resample (changement de frequence)

Resample mensuel

# Regroupement des donnees par mois

# Ici , on calcule la moyenne mensuelle

monthly_mean = df . resample ( " M " ) . mean ()

print ( monthly_mean . head () )

Donc pour que tu te souviennes:

• rolling = calcul local dans le temps

• resample = changement de frequence temporelle

Par mes soins - Ghali Mikou Page 25/29

14. Visualisation rapide

Plot simple sur une Series

Visualisation d une colonne

# Trace directement la serie de prix

# Utilise matplotlib en interne

df [ " price " ]. plot ()

Plot depuis un DataFrame

Plot avec axes explicites

# Definition explicite de l axe x et de l axe y

# Tres utile quand date n est pas l index

df . plot ( x = " date " , y = " price " )

A savoir :

• Si date est l index, df["price"].plot() suffit.

• Pour des graphiques propres et pro, utiliser matplotlib ou seaborn.

Par mes soins - Ghali Mikou Page 26/29

15. Verifications et assertions (data quality)

Objectif : verifier automatiquement que les donnees sont exploitables. Les assertions permettent de
faire echouer un script si les donnees sont incoherentes.
Lecture mentale :

• Si la condition est vraie → le code continue.

• Si la condition est fausse → le script s arrete avec une erreur.

Exemples de verifications courantes

Verification de base sur un DataFrame

# Verifie que le DataFrame contient au moins une ligne

assert df . shape [0] > 0

# Verifie que la colonne price ne contient aucun NaN

assert df [ " price " ]. notna () . all ()

Usage typique :

• Apres un read_csv ou read_excel.

• Avant un calcul critique ou un reporting.

Autres assertions utiles

Assertions frequentes en pratique

# Verifie qu une colonne existe

assert " price " in df . columns

# Verifie que les valeurs sont positives

assert ( df [ " price " ] > 0) . all ()

# Verifie qu il n y a pas de doublons sur une cle

assert df [ " trade_id " ]. is_unique

Si tu veux vraiment flexxxx, garde ca en tete :

• Les assertions remplacent des if silencieux.

• Une erreur franche est preferable a un resultat faux.

Mini exercices (enonces)

1. Verifier que le DataFrame trades contient au moins 10 lignes.

2. Verifier que la colonne quantity ne contient aucun NaN.

3. Verifier que toutes les valeurs de amount sont strictement positives.

4. Verifier que la colonne order_id ne contient aucun doublon.

Par mes soins - Ghali Mikou Page 27/29

Corrections

assert trades . shape [0] >= 10

assert trades [ " quantity " ]. notna () . all ()

assert ( trades [ " amount " ] > 0) . all ()

assert trades [ " order_id " ]. is_unique

Par mes soins - Ghali Mikou Page 28/29

Note amicale pour les plus temeraires

Si tu es arrive jusqu ici, felicitations le tigre. Ca veut dire que t’es plus ou moins calé pour tes entretiens.

Si tu tombes en entretien sur des trucs qui ne sont pas évoqués dans cette fiche, j’espère que le pay
package est bon... Sinon, je te permets de t’acharner sur moi.

Si tu as des questions, besoin de projets concrets pour t entrainer, envie de plus d exercices pour monter
en niveau, ou simplement envie de me 1v1 sur clash royale, n hesite pas a me contacter.

Tu peux me trouver sur LinkedIn : Ghali Mikou. Il y en a quelques uns qui partagent le même nom,
mais j espere etre le plus frais.

En tout cas merci d avoir pris le temps de me lire, et bon courage pour la suite.

Mes amitiés,
Ghali

Par mes soins - Ghali Mikou Page 29/29

 Mini-projet Pandas

Énoncé — Mini-projet Pandas (version modifiée)

On dispose d’une base de données produits e-commerce contenant le nom du produit, le
stock disponible, l’entrepôt de stockage et une marge associée (en euros).
Le travail consiste à créer le dataset, l’exporter, le relire, l’analyser, le nettoyer et produire
des statistiques.

Données à utiliser pour créer le dataset

Tu dois créer un dictionnaire Python data contenant exactement les informations suivantes :
— produit :
["Casque", "Souris", "Clavier", "Webcam", "SSD", "Chargeur",
"Hub USB", "Ecran", "Micro", "Support PC"]

— stock :
[15, 42, 8, 0, 27, 64, 3, 12, 5, 31]

— entrepot :
["Nord", "Sud", "Nord", "Ouest", "Nord", "Nord",
"Est", "Nord", "Nord", "Centre"]

— marge :
[85, -10, 25, 5, -40, 18, -6, 60, -2, 12]

Questions
1. Créer un DataFrame pandas nommé df à partir du dictionnaire data.
2. Exporter le DataFrame df dans un fichier CSV nommé [Link] en utilisant un sépara-
teur ; et sans écrire l’index.
3. Lire le fichier [Link] avec pandas en précisant le séparateur utilisé, et stocker le résultat
dans df.
4. Afficher les 10 premières lignes du DataFrame, les 5 dernières lignes, puis afficher 5 lignes
tirées aléatoirement avec un tirage reproductible.
5. Afficher les dimensions du DataFrame, les noms des colonnes et les types de données associés
à chaque colonne.
6. Afficher les statistiques descriptives des colonnes numériques du DataFrame.
7. Créer un nouveau DataFrame df2 contenant uniquement les colonnes produit, stock et
entrepot.
8. Créer un DataFrame df_stock20 contenant uniquement les produits dont le stock est stric-
tement supérieur à 20.

1
 9. Créer un DataFrame df_nord contenant uniquement les produits stockés dans l’entrepôt
"Nord".
10. Créer un DataFrame df_nord_20 contenant uniquement les produits dans l’entrepôt "Nord"
et dont le stock est strictement supérieur à 20.
11. Créer un DataFrame df_outliers contenant uniquement les produits dont le stock est infé-
rieur à 5 ou supérieur à 50.
12. Exporter df_nord_20 dans nord_20.csv et df_outliers dans outliers_stock.xlsx, sans
index.
13. Créer une copie df_na et introduire des valeurs manquantes : stock = NaN aux index 1 et 4,
entrepot = NaN à l’index 6.
14. Calculer le nombre et le pourcentage de valeurs manquantes par colonne.
15. Créer df_drop_all en supprimant les lignes contenant au moins une valeur manquante.
16. Créer df_drop_stock en supprimant uniquement les lignes où stock est manquant.
17. Créer df_fill0 en remplaçant toutes les valeurs manquantes par 0.
18. Créer df_fill_rules : moyenne pour stock, "Inconnu" pour entrepot.
19. Créer df_fill_median : médiane pour stock, "Inconnu" pour entrepot.
20. Créer df_edit et remplacer -2 par 0 dans marge.
21. Remplacer "Nord" par "NORD" dans entrepot.
22. Remplacer stock = 15 par 20.
23. Afficher le comptage de entrepot (valeurs, proportions, avec NaN).
24. Afficher le nombre et la liste des valeurs uniques de entrepot.
25. Calculer toutes les statistiques usuelles et quantiles pour marge.
26. Afficher les statistiques descriptives globales, toutes colonnes, puis textuelles.
27. Calculer les corrélations Pearson, Spearman, Kendall et la corrélation stock/marge.
28. Afficher la matrice de covariance.
29. Calculer la skewness globale puis celle de marge.
30. Calculer la kurtosis globale puis celle de marge.
31. Trier df_edit par marge décroissante puis stock croissant.
32. Réinitialiser l’index.
33. Créer categorie_stock : Faible / Moyen / Élevé.
34. Compter les produits par catégorie.
35. Calculer la marge totale par entrepôt.
36. Calculer marge moyenne, médiane et stock total par entrepôt.
37. Identifier l’entrepôt le plus rentable et celui avec le stock le plus faible.
38. Créer df_positive (marge > 0).
39. Calculer la proportion de produits rentables.
40. Ajouter la colonne booléenne rentable.
41. Créer un tableau croisé entrepot / rentable.
42. Calculer la marge cumulée triée par stock.

2
43. Normaliser stock (min-max).
44. Standardiser marge (z-score).
45. Identifier les valeurs aberrantes sur marge_std.
46. Calculer la contribution de chaque produit à la marge totale.
47. Créer df_summary par entrepôt (effectif, stock moyen, marge totale, marge moyenne).
48. Exporter df_summary vers summary_entrepots.xlsx.
49. Détecter les doublons.
50. Supprimer les doublons en conservant la première occurrence.

3
 Mini-projet Pandas — Correction complète

Correction Python — Questions 1 à 50

"""
Mini-projet Pandas Correction complte (Questions 1 50)
Contexte : produits e-commerce
Colonnes : produit, stock, entrepot, marge
"""

import numpy as np
import pandas as pd

# =========================
# Donnes de dpart
# =========================
data = {
"produit": ["Casque", "Souris", "Clavier", "Webcam", "SSD",
"Chargeur", "Hub USB", "Ecran", "Micro", "Support PC"],
"stock": [15, 42, 8, 0, 27, 64, 3, 12, 5, 31],
"entrepot": ["Nord", "Sud", "Nord", "Ouest", "Nord",
"Nord", "Est", "Nord", "Nord", "Centre"],
"marge": [85, -10, 25, 5, -40, 18, -6, 60, -2, 12],
}

# 1) Crer le DataFrame
df = [Link](data)

# 2) Export CSV
df.to_csv("[Link]", sep=";", index=False)

# 3) Lecture CSV
df = pd.read_csv("[Link]", sep=";")

# 4) Affichages
[Link](10)
[Link](5)
[Link](5, random_state=42)

# 5) Infos structurelles
[Link]
[Link]
[Link]

# 6) Statistiques descriptives numriques

[Link]()

# 7) Sous-DataFrame
df2 = df[["produit", "stock", "entrepot"]]

1
# 8) Stock > 20
df_stock20 = df[df["stock"] > 20]

# 9) Entrept Nord
df_nord = df[df["entrepot"] == "Nord"]

# 10) Nord et stock > 20

df_nord_20 = df[(df["entrepot"] == "Nord") & (df["stock"] > 20)]

# 11) Outliers stock

df_outliers = df[(df["stock"] < 5) | (df["stock"] > 50)]

# 12) Exports
df_nord_20.to_csv("nord_20.csv", sep=";", index=False)
df_outliers.to_excel("outliers_stock.xlsx", index=False)

# 13) Valeurs manquantes volontaires

df_na = [Link]()
df_na.loc[[1, 4], "stock"] = [Link]
df_na.loc[6, "entrepot"] = [Link]

# 14) Comptage NaN

df_na.isna().sum()
df_na.isna().mean() * 100

# 15) Drop toutes lignes NaN

df_drop_all = df_na.dropna()

# 16) Drop NaN sur stock

df_drop_stock = df_na.dropna(subset=["stock"])

# 17) Fill NaN par 0

df_fill0 = df_na.fillna(0)

# 18) Fill rgles (moyenne + "Inconnu")

df_fill_rules = df_na.copy()
df_fill_rules["stock"] = df_fill_rules["stock"].fillna(df_fill_rules["stock"].mean())
df_fill_rules["entrepot"] = df_fill_rules["entrepot"].fillna("Inconnu")

# 19) Fill mdiane + "Inconnu"

df_fill_median = df_na.copy()
df_fill_median["stock"] = df_fill_median["stock"].fillna(df_fill_median["stock"].median()
)
df_fill_median["entrepot"] = df_fill_median["entrepot"].fillna("Inconnu")

# 20) Edition marge

df_edit = [Link]()
df_edit["marge"] = df_edit["marge"].replace(-2, 0)

# 21) Normalisation texte

df_edit["entrepot"] = df_edit["entrepot"].replace("Nord", "NORD")

# 22) Remplacer stock = 15 par 20

df_edit.loc[df_edit["stock"] == 15, "stock"] = 20

# 23) Value counts

df_edit["entrepot"].value_counts()
df_edit["entrepot"].value_counts(normalize=True)
df_edit["entrepot"].value_counts(dropna=False)

2
# 24) Uniques
df_edit["entrepot"].nunique()
df_edit["entrepot"].unique()

# 25) Statistiques marge

m = df_edit["marge"]
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]()
[Link]([0.25, 0.5, 0.75])
[Link]([0.1, 0.25, 0.5, 0.75, 0.9])

# 26) Describe global

df_edit.describe()
df_edit.describe(include="all")
df_edit.describe(include=["object"])

# 27) Corrlations
df_edit[["stock", "marge"]].corr(method="pearson")
df_edit[["stock", "marge"]].corr(method="spearman")
df_edit[["stock", "marge"]].corr(method="kendall")
df_edit["stock"].corr(df_edit["marge"])

# 28) Covariance
df_edit[["stock", "marge"]].cov()

# 29) Skewness
df_edit.select_dtypes(include="number").skew()
df_edit["marge"].skew()

# 30) Kurtosis
df_edit.select_dtypes(include="number").kurt()
df_edit["marge"].kurt()

# 31) Tri
df_sorted = df_edit.sort_values(by=["marge", "stock"], ascending=[False, True])

# 32) Reset index

df_sorted.reset_index(drop=True, inplace=True)

# 33) Catgories stock

conditions = [
df_edit["stock"] < 10,
(df_edit["stock"] >= 10) & (df_edit["stock"] <= 30),
df_edit["stock"] > 30
]
choices = ["Faible", "Moyen", "lev"]
df_edit["categorie_stock"] = [Link](conditions, choices)

# 34) Comptage catgories

df_edit["categorie_stock"].value_counts()

# 35) Marge totale par entrept

3
df_edit.groupby("entrepot")["marge"].sum()

# 36) Stats par entrept

df_edit.groupby("entrepot").agg(
marge_moyenne=("marge", "mean"),
marge_mediane=("marge", "median"),
stock_total=("stock", "sum")
)

# 37) Entrepts extrmes

df_edit.groupby("entrepot")["marge"].sum().idxmax()
df_edit.groupby("entrepot")["stock"].sum().idxmin()

# 38) Produits rentables

df_positive = df_edit[df_edit["marge"] > 0]

# 39) Proportion rentable

(df_edit["marge"] > 0).mean()

# 40) Boolen rentable

df_edit["rentable"] = df_edit["marge"] > 0

# 41) Crosstab
[Link](df_edit["entrepot"], df_edit["rentable"])

# 42) Marge cumule

df_edit.sort_values("stock")["marge"].cumsum()

# 43) Normalisation stock

df_edit["stock_norm"] = (df_edit["stock"] - df_edit["stock"].min()) / \
(df_edit["stock"].max() - df_edit["stock"].min())

# 44) Standardisation marge

df_edit["marge_std"] = (df_edit["marge"] - df_edit["marge"].mean()) / df_edit["marge"].
std()

# 45) Outliers marge_std

df_edit[(df_edit["marge_std"] > 1) | (df_edit["marge_std"] < -1)]

# 46) Contribution marge (%)

df_edit["contribution_marge_pct"] = df_edit["marge"] / df_edit["marge"].sum() * 100

# 47) DataFrame rsum

df_summary = df_edit.groupby("entrepot").agg(
nb_produits=("produit", "count"),
stock_moyen=("stock", "mean"),
marge_totale=("marge", "sum"),
marge_moyenne=("marge", "mean")
).reset_index()

# 48) Export rsum

df_summary.to_excel("summary_entrepots.xlsx", index=False)

# 49) Doublons
df_edit.duplicated().any()
df_edit[df_edit.duplicated(keep=False)]

# 50) Suppression doublons

df_no_duplicates = df_edit.drop_duplicates()