GUIDE COMPLET
Certification Python 3 — Journee 3
Pandas : Series, DataFrame, Nettoyage, GroupBy, Pivot Table, Visualisation
Ce document couvre le Module 3 : Pandas complet (Series, DataFrame, loc/iloc, CSV,
nettoyage des donnees, GroupBy, Pivot Table, Merge, style et visualisation).
1. PANDAS — LES SERIES
1.1 Creer une Serie
Une Serie = colonne de donnees avec un index. Comme un tableau 1D etiquete.
import pandas as pd
import numpy as np
# Depuis une liste
s = [Link]([10, 20, 30]) # index auto : 0, 1, 2
# Depuis un dictionnaire (cles => index)
sports = {'Golf': 'Scotland', 'Sumo': 'Japan', 'Taekwondo': 'Korea'}
s = [Link](sports)
# Index = Golf, Sumo, Taekwondo
# Forcer un index personnalise
s = [Link](sports, index=['Golf', 'Sumo', 'Hockey'])
# Hockey absent => NaN automatiquement
# Depuis numpy
s = [Link]([Link](0, 1000, 100))
1.2 Acceder aux elements d'une Serie
Methode Syntaxe Acces par
.iloc[] [Link][3] Position entiere (0, 1, 2...)
.loc[] [Link]['Golf'] Label / etiquette
[] s[0] Position (attention si index
numerique !)
.head() [Link](5) 5 premiers elements
.tail() [Link](5) 5 derniers elements
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 1
Methode Syntaxe Acces par
.index [Link] Voir l'index
.values [Link] Tableau numpy des valeurs
PIEGE : Si l'index est numerique (99, 100, 101...), s[0] leve une KeyError !
Toujours utiliser [Link][0] pour l'acces par position en cas de doute.
[Link]['label'] => acces par etiquette | [Link][n] => acces par position entiere
1.3 Operations sur les Series
s = [Link]([Link](0, 1000, 100))
# Broadcasting : operation appliquee a tous les elements
s += 2 # ajoute 2 a chaque valeur
s * 3 # multiplie par 3
# Ajouter un element
[Link]['Animal'] = 'Bears' # ajoute une nouvelle entree
# Fusionner deux Series (union des index)
s3 = [Link](s2) # les index en commun sont tous gardes
2. LE DATAFRAME — LA STRUCTURE PRINCIPALE
2.1 Creer un DataFrame
import pandas as pd
# Depuis une liste de Series (chaque Serie = une ligne)
row1 = [Link]({'Name': 'Chris', 'Item': 'Dog Food', 'Cost': 22.50})
row2 = [Link]({'Name': 'Kevyn', 'Item': 'Kitty Litter', 'Cost': 2.50})
df = [Link]([row1, row2], index=['Store 1', 'Store 2'])
# Depuis un dictionnaire de listes (chaque cle = une colonne)
df = [Link]({
'team': ['A', 'A', 'B', 'B'],
'points': [5, 7, 12, 9],
'assists': [11, 8, 6, 5]
})
# Depuis un fichier CSV
df = pd.read_csv('[Link]')
df = pd.read_csv('[Link]', index_col=0, skiprows=1) # options avancees
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 2
2.2 Explorer un DataFrame — METHODES ESSENTIELLES
Methode / Attribut Description
[Link](n) n premieres lignes (5 par defaut)
[Link](n) n dernieres lignes
[Link] (nb_lignes, nb_colonnes)
[Link] Type de chaque colonne
[Link]() Statistiques : mean, std, min, max...
[Link] Liste des noms de colonnes
[Link] Index du DataFrame
[Link]() Infos generales + valeurs manquantes
df['colonne'] Selectionner une colonne (retourne une Serie)
df[['col1','col2']] Selectionner plusieurs colonnes (retourne un
DataFrame)
2.3 loc et iloc — SELECTION DE LIGNES/COLONNES
Deux methodes fondamentales pour selectionner des donnees dans un DataFrame.
df = [Link]({...}, index=['A','B','C','D','E','F','G','H'])
# --- loc : selection par LABEL (etiquette) ---
[Link]['E'] # ligne avec label 'E'
[Link][['E','F']] # lignes E et F
[Link]['E':'G'] # lignes de E a G inclus
[Link]['E', 'team'] # cellule exacte
[Link][['E','F'], ['team','assists']] # sous-tableau
# --- iloc : selection par POSITION entiere ---
[Link][4] # ligne a la position 4 (0-indexe)
[Link][4:6] # positions 4 et 5 (6 exclus)
[Link][0:3, 0:2] # 3 premieres lignes, 2 premieres colonnes
# --- Filtrage par condition ---
df[df['points'] > 8] # lignes ou points > 8
df[df['team'] == 'A'] # lignes ou team = 'A'
df[(df['points'] > 5) & (df['team'] == 'A')] # ET logique
df[(df['Gold'] > 0) | (df['Silver'] > 0)] # OU logique
DIFFERENCE CLF : loc[a:b] inclut b | iloc[a:b] exclut b (comme range())
loc utilise les labels d'index (texte ou nombre)
iloc utilise toujours des positions entieres 0, 1, 2...
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 3
2.4 Modifier un DataFrame
# Ajouter / modifier une colonne
df['Date'] = ['Dec 1', 'Jan 1', 'May 15'] # nouvelle colonne
df['Delivered'] = True # meme valeur pour toutes les lignes
df['Net'] = df['Revenue'] - df['Cost'] # colonne calculee
# Renommer des colonnes
[Link](columns={'ancien_nom': 'nouveau_nom'}, inplace=True)
[Link](columns={'Shape Reported': 'Forme', 'Colors': 'Couleur'}, inplace=True)
# Supprimer une colonne
[Link](columns=['col_inutile'], inplace=True)
df = [Link](['col1', 'col2'], axis=1) # axis=1 = colonnes
# Changer l'index
df = df.set_index('Name') # une colonne devient l'index
df = df.reset_index() # remet un index numerique auto
# Reordonner les colonnes
new_cols = ['City', 'Forme', 'Couleur', 'State', 'Time']
df = df[new_cols]
3. NETTOYAGE DES DONNEES (DATA CLEANING)
3.1 Reperer les valeurs manquantes
# Verifier les valeurs manquantes
[Link]() # True/False pour chaque cellule
[Link]() # equivalent a isna()
[Link]().sum() # nombre de NaN par colonne
[Link]().sum().sum() # total de NaN dans tout le DataFrame
# Verifier une colonne specifique
df['col'].isna().sum() # nb NaN dans cette colonne
3.2 Traiter les valeurs manquantes
# Supprimer les lignes avec NaN
[Link]() # supprime si AU MOINS un NaN
[Link](how='any') # idem (defaut)
[Link](how='all') # supprime seulement si TOUTE la ligne est NaN
[Link](subset=['col1', 'col2']) # seulement si NaN dans ces colonnes
# Remplacer les NaN par une valeur
df['col'].fillna('VARIOUS', inplace=True) # remplace par 'VARIOUS'
[Link](0) # remplace tous les NaN par 0
df['col'].fillna(df['col'].mean()) # remplace par la moyenne
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 4
3.3 Reperer et supprimer les doublons
# Detecter les doublons
[Link]() # True pour chaque doublon
[Link](['City', 'State'], keep='last')# doublons sur certaines colonnes
[Link]().sum() # nombre de doublons
# Supprimer les doublons
df.drop_duplicates(inplace=True) # garde la 1ere occurrence
df.drop_duplicates(keep=False, inplace=True) # supprime TOUTES les occurrences
df.drop_duplicates(subset=['City'], keep='first')
3.4 Changer le type de donnees
# Voir les types actuels
[Link]
# Convertir une colonne en datetime
df['Time'] = pd.to_datetime(df['Time']) # RECOMMANDE pour les dates
# Convertir en numerique
df['Prix'] = pd.to_numeric(df['Prix']) # int ou float automatiquement
df['Prix'] = pd.to_numeric(df['Prix'], errors='coerce') # NaN si erreur
# Convertir avec astype
df['col'] = df['col'].astype('float64')
df['col'] = df['col'].astype('int32')
df['col'] = df['col'].astype('str')
BONNE PRATIQUE de nettoyage (ordre recommande) :
1. Charger le CSV 2. Supprimer colonnes inutiles 3. Verifier les types (dtypes)
4. Detecter les NaN (isna().sum()) 5. Traiter les NaN (fillna/dropna)
6. Supprimer les doublons (drop_duplicates) 7. Renommer colonnes 8. Reindexer
3.5 Exemple complet de nettoyage
import pandas as pd
# 1. Charger
df = pd.read_csv('[Link]')
# 2. Supprimer colonne inutile
[Link](columns=['Unnamed: 0'], inplace=True)
# 3. Infos generales
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 5
print([Link]) # dimensions
print([Link]) # types
print([Link]().sum()) # valeurs manquantes
# 4. Supprimer lignes entierement vides
df = [Link](how='all')
# 5. Remplacer NaN dans une colonne
df['Shape Reported'].fillna('Various', inplace=True)
# 6. Supprimer doublons
df.drop_duplicates(inplace=True)
# 7. Convertir type
df['Time'] = pd.to_datetime(df['Time'])
# 8. Renommer colonnes
[Link](columns={'Shape Reported': 'Forme', 'Colors Reported': 'Couleur'},
inplace=True)
# 9. Reordonner colonnes
df = df[['City', 'Forme', 'Couleur', 'State', 'Time']]
4. GROUPBY — REGROUPEMENT ET AGREGATION
4.1 Principe
groupby() regroupe les lignes selon les valeurs d'une colonne, puis applique une fonction d'agregation.
import pandas as pd
data = {'Nom': ['John','Anna','John','Anna','John','Anna'],
'Matiere': ['Maths','Maths','Physique','Physique','Chimie','Chimie'],
'Score': [85, 90, 78, 88, 92, 95]}
df = [Link](data)
# Grouper par une colonne
grouped = [Link]('Nom')
# Parcourir les groupes
for valeur, group in grouped:
print(valeur)
print(group)
# Grouper par plusieurs colonnes
grouped2 = [Link](['Nom', 'Matiere'])
for (nom, matiere), group in grouped2:
print(nom, matiere)
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 6
4.2 Fonctions d'agregation avec groupby
Fonction Description
.sum() Somme des valeurs numeriques
.mean() Moyenne
.count() Nombre d'elements (fonctionne aussi sur non-numerique)
.min() / .max() Minimum / Maximum
.std() Ecart-type
.agg({'col': func}) Agregation personnalisee par colonne
.apply(lambda x: ...) Fonction personnalisee sur chaque groupe
.size() Nombre de lignes par groupe
# Somme des scores par personne
[Link]('Nom').sum()
# Moyenne avec agg
[Link]('Nom').agg({'Score': 'mean'})
# Fonction personnalisee (max - min)
[Link]('Nom')['Score'].apply(lambda x: [Link]() - [Link]())
# Compter (fonctionne sur texte aussi)
[Link]('Nom').count()
# Trier le resultat
[Link]('Nom')['Score'].sum().sort_values(ascending=False)
# Sur donnees Census : moyenne de population par etat
[Link]('STNAME').agg({'CENSUS2010POP': 'mean'})
5. PIVOT TABLE — TABLEAU CROISE DYNAMIQUE
5.1 Principe
pivot_table() cree un tableau a double entree (lignes + colonnes) avec agregation. Ideal pour analyse
multidimensionnelle.
5.2 Syntaxe
pd.pivot_table(df,
index='colonne_lignes', # valeurs qui deviennent les lignes
columns='colonne_cols', # valeurs qui deviennent les colonnes
values='colonne_valeurs', # valeurs a agreger
aggfunc='mean' # fonction : 'mean', 'sum', 'count', 'max', 'min'
)
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 7
import pandas as pd
import numpy as np
# Exemple : ventes par region
sales_by_region = pd.pivot_table(df, index='Region', values='Sales')
# aggfunc='mean' par defaut
# Avec somme
pd.pivot_table(df, index='Region', values='Sales', aggfunc='sum')
# Double entree : type par region, valeur = max des unites
pd.pivot_table(df, index='Type', columns='Region', values='Units', aggfunc='max')
# Remplacer les NaN par 0
pd.pivot_table(df, index='Type', columns='Region', values='Units',
aggfunc='max', fill_value=0)
# Plusieurs fonctions d'agregation
pd.pivot_table(df, index='Name', columns='Date', aggfunc=['sum','count'])
# Marges (totaux) avec margins=True
pd.pivot_table(df, index='Name', columns='Date', aggfunc='sum', margins=True)
# margins=True ajoute une ligne 'All' et une colonne 'All' avec les totaux
5.3 GroupBy vs Pivot Table — Quand utiliser lequel ?
Critere GroupBy vs Pivot Table
Resultat 1D (une dimension) groupby() => resultat en Serie ou DataFrame simple
Resultat 2D (lignes ET pivot_table() => tableau croise avec deux dimensions
colonnes)
Aggregation simple groupby().sum() / .mean() => plus rapide
Analyse multi- pivot_table() => rows + columns en meme temps
dimensionnelle
Donnees non numeriques groupby().count() fonctionne | pivot_table() plus
limite
Totaux automatiques pivot_table(margins=True) => lignes/colonnes de totaux
RESUME : GroupBy = aggreger selon UNE categorie (resultat 1D)
Pivot Table = aggreger selon DEUX categories (resultat 2D, comme Excel)
ASTUCE : pd.pivot_table(df, index=['colX'], columns=['colY'], aggfunc=len)
est equivalent a : [Link](['colX','colY']).size().unstack('colY')
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 8
6. MERGE — FUSIONNER DES DATAFRAMES
6.1 Types de jointures
Type how= Description
Inner join 'inner' Seulement les lignes communes aux deux DataFrames
Outer join 'outer' Toutes les lignes (NaN si absent dans l'un)
Left join 'left' Toutes les lignes du DataFrame GAUCHE
Right join 'right' Toutes les lignes du DataFrame DROIT
6.2 Syntaxe merge
import pandas as pd
# Creer deux DataFrames
staff_df = [Link]([
{'Name': 'Kelly', 'Role': 'Director'},
{'Name': 'Sally', 'Role': 'Liaison'},
{'Name': 'James', 'Role': 'Grader'}
]).set_index('Name')
student_df = [Link]([
{'Name': 'James', 'School': 'Business'},
{'Name': 'Mike', 'School': 'Law'},
{'Name': 'Sally', 'School': 'Engineering'}
]).set_index('Name')
# OUTER : toutes les lignes
[Link](staff_df, student_df, how='outer', left_index=True, right_index=True)
# INNER : seulement James et Sally (communs)
[Link](staff_df, student_df, how='inner', left_index=True, right_index=True)
# LEFT : tous les staff, NaN pour Mike absent de staff
[Link](staff_df, student_df, how='left', left_index=True, right_index=True)
# Merge sur une colonne (apres reset_index)
[Link](staff_df.reset_index(), student_df.reset_index(),
how='left', left_on='Name', right_on='Name')
# Merge avec colonnes en conflit (suffixes automatiques)
[Link](staff_df, student_df, how='left',
left_on='Name', right_on='Name',
suffixes=['_staff', '_student'])
PIEGE : Si les deux DataFrames ont une colonne du meme nom (ex: 'Location'),
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 9
Pandas ajoute les suffixes _x et _y automatiquement.
Utiliser suffixes=['_staff','_student'] pour nommer explicitement.
7. MELT — TRANSFORMER LA FORME DU DATAFRAME
7.1 Principe
melt() transforme un DataFrame de format LARGE (colonnes = variables) en format LONG (une colonne
'variable' et une colonne 'valeur').
import pandas as pd
df = [Link]({
'Name': ['Olivia', 'John', 'Laura'],
'Attendance': [60, 100, 80],
'Obtained Marks': ['90%', '75%', '82%']
})
# melt sans options : toutes les colonnes fondues
df_melt = [Link](df)
# Resultat : colonnes 'variable' et 'value'
# Garder 'Name' comme identifiant fixe
df_melt = [Link](df, id_vars=['Name'])
# Chaque ligne = (Name, variable, value)
# Renommer les colonnes resultantes
df_melt = [Link](df, id_vars=['Name'],
var_name='Performance',
value_name='Success')
8. CHAINING — ENCHAINER LES OPERATIONS
8.1 Principe
Pandas permet d'enchainer les methodes sur une seule ligne pour un code plus lisible.
# Style procedural (classique)
df = df[df['SUMLEV'] == 50]
df.set_index(['STNAME', 'CTYNAME'], inplace=True)
[Link](columns={'ESTIMATESBASE2010': 'Estimates Base 2010'}, inplace=True)
# Style chaining (enchaine)
df = (df
.where(df['SUMLEV'] == 50) # garde seulement SUMLEV==50
.dropna() # supprime les lignes NaN
.set_index(['STNAME', 'CTYNAME']) # definit l'index
.rename(columns={'ESTIMATESBASE2010': 'Estimates Base 2010'})
).head()
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 10
# Autre exemple : filtre + tri + selection
df[df['Gold'] > 0].sort_values('Gold', ascending=False).head(10)
9. STYLE ET VISUALISATION DU DATAFRAME
9.1 Mise en evidence des valeurs
# Mettre en evidence le maximum de chaque colonne
[Link](5).style.highlight_max(color='yellow')
# Minimum en rouge
[Link](10).style.highlight_min(color='red')
# Max ET min
[Link](10).style.highlight_max(color='yellow').highlight_min(color='red')
# Mettre en evidence les valeurs nulles/manquantes
[Link](10).style.highlight_null(null_color='red')
# Gradient de couleur
[Link](10).style.background_gradient(cmap='Blues')
# Barre de progression en fond
[Link](10).sort_values(by='price').[Link](color='blue')
9.2 Affichage personnalise
# Masquer l'index
[Link](10).[Link](axis='index')
# Masquer des colonnes inutiles
[Link](10).[Link](axis='index').hide_columns(['index', 'company'])
# Graphique depuis un DataFrame
import [Link] as plt
[Link](kind='area') # aire
[Link](kind='bar') # barres
[Link](kind='line') # lignes
[Link](kind='scatter', x='col1', y='col2') # nuage de points
[Link]() # afficher le graphique
# KDE (densite de probabilite)
[Link][3:, 1:7].[Link](subplots=True, figsize=(12, 9))
[Link]()
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 11
10. RECAP EXPRESS — FONCTIONS PANDAS ESSENTIELLES
Categorie Fonction Usage
Lecture pd.read_csv('[Link]') Charger un CSV
Exploration [Link]() / .tail() Voir les premieres/dernieres
lignes
Exploration [Link] / .dtypes Dimensions et types
Exploration [Link]() Statistiques descriptives
Selection df['col'] Une colonne
Selection [Link][label] Ligne par etiquette
Selection [Link][pos] Ligne par position
Filtrage df[df['col']>5] Condition de filtrage
Modif colonne [Link](columns={}) Renommer colonnes
Modif colonne [Link](columns=[]) Supprimer colonnes
Modif index df.set_index('col') Definir index
Modif index df.reset_index() Reinitialiser index
Nettoyage [Link]().sum() Compter les NaN
Nettoyage [Link](valeur) Remplacer NaN
Nettoyage [Link]() Supprimer lignes NaN
Nettoyage df.drop_duplicates() Supprimer doublons
Nettoyage [Link]() / Changer type
pd.to_datetime()
Agregation [Link]('col').sum() Grouper + somme
Agregation [Link]().agg({}) Agregation personnalisee
Agregation pd.pivot_table(df,...) Tableau croise
Fusion [Link](df1, df2, how=) Fusionner deux DataFrame
Transformation [Link](df, id_vars=[]) Format large => long
Visualisation [Link](kind='bar') Graphique rapide
Style [Link].highlight_max() Mettre en evidence
11. PIEGES FREQUENTS — PANDAS
PIEGE 1 : loc vs iloc et l'index numerique
Si l'index est numerique (ex: 99,100,101), s[0] => KeyError !
Toujours utiliser .iloc[0] pour position, .loc[label] pour etiquette.
PIEGE 2 : inplace=True oublie
[Link](columns={...}) SANS inplace=True ne modifie pas df !
Toujours ajouter inplace=True ou reassigner : df = [Link](...)
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 12
PIEGE 3 : loc[a:b] inclut b, iloc[a:b] exclut b
[Link]['A':'C'] => A, B, C (C inclus)
[Link][0:3] => positions 0, 1, 2 (3 exclu, comme range())
PIEGE 4 : drop() sur lignes vs colonnes
[Link]('colonne', axis=1) => supprime une colonne
[Link](0, axis=0) => supprime une ligne (axis=0 par defaut)
PIEGE 5 : groupby().sum() vs pivot_table()
groupby => resultat 1D (une ligne par groupe)
pivot_table => resultat 2D (lignes ET colonnes simultanement)
PIEGE 6 : aggfunc par defaut dans pivot_table
pd.pivot_table() utilise aggfunc='mean' par defaut !
Pour une somme, toujours specifier aggfunc='sum'
PIEGE 7 : merge avec colonnes en conflit
Si les deux DataFrames ont une colonne 'Location', merge ajoute _x et _y.
Utiliser suffixes=['_gauche','_droite'] pour nommer explicitement.
Bonne chance a l'examen !
Guide Python 3 — Journee 3 : Pandas & Data Science | Page 13