Programme de formation Python - Analyse de données (5h)
Module 1: Environnement & prise en main (30 minutes)
A. Installation et configuration (12 min)
1. Pourquoi Python pour l'analyse de données ? (3 min)
Points à couvrir :
Simplicité syntaxique : Comparaison avec R, SAS, SPSS
Écosystème riche : NumPy, Pandas, Matplotlib, Scikit-learn
Polyvalence : Web, IA, automatisation, analyse de données
Communauté active : Support, documentation, tutoriels
Démonstration comparative :
python
# Python - simple et lisible
moyenne = sum(notes) / len(notes)
2. Distribution Anaconda vs Python standard (4 min)
Avantages d'Anaconda :
Pré-installé : 250+ packages scientifiques
Gestionnaire de packages : conda vs pip
Environnements virtuels : Isolation des projets
Interface graphique : Anaconda Navigator
Outils intégrés : Jupyter, Spyder, VS Code
Installation pratique :
Téléchargement depuis [Link]
Installation step-by-step
Vérification de l'installation
Configuration du PATH
3. Environnements de développement (5 min)
Comparaison des IDE :
Jupyter Notebook : Idéal pour exploration de données
Jupyter Lab : Version avancée avec interface moderne
Spyder : IDE scientifique (comme RStudio)
VS Code : Éditeur universel avec extensions Python
PyCharm : IDE professionnel complet
Critères de choix :
Niveau de l'utilisateur
Type de projet (exploration vs production)
Préférences d'interface
B. Maîtrise complète de Jupyter Notebook (10 min)
1. Interface et navigation (4 min)
Éléments de l'interface :
Dashboard → Notebooks → Cells → Kernel
Navigation détaillée :
Arborescence : Création/organisation de dossiers
Nouveau notebook : Choix du kernel Python
Renommage : Bonnes pratiques de nommage
Sauvegarde : Automatique vs manuelle, format .ipynb
États du notebook :
Mode édition (cellule active, curseur visible)
Mode commande (contour bleu, pas de curseur)
Kernel occupé (indicateur en haut à droite)
2. Types de cellules et leur utilisation (3 min)
python
# Cellule de code - pour l'exécution Python
print("Hello World")
x = 10
y = 20
resultat = x + y
markdown
# Documentation et explications
## Objectifs de cette section
- Point 1
- Point 2
**Important** : Les cellules Markdown permettent de documenter le code
3. Raccourcis clavier avancés (3 min)
Navigation :
↑/↓ : Naviguer entre cellules
Enter : Passer en mode édition
Esc : Passer en mode commande
Exécution :
Shift + Enter : Exécuter et passer à la suivante
Ctrl + Enter : Exécuter sans changer de cellule
Alt + Enter : Exécuter et insérer nouvelle cellule
C. Markdown avancé pour documentation (8 min)
1. Syntaxe de base enrichie (4 min)
markdown
# Titres hiérarchiques
## Formatage du texte
**gras**, *italique*, `code inline`
> Citations
- Listes
1. Numérotées
2. Listes et structures (2 min)
markdown
- [x] Listes de tâches
- [ ] Tâche en cours
3. Éléments avancés (2 min)
markdown
| Tableaux | Alignés |
|----------|---------|
| Données | Centré |
[Liens]([Link]
Module 2: Bases approfondies du langage (1h)
A. Types de données complets (25 min)
1. Nombres et opérations avancées (8 min)
python
# Entiers et flottants
entier = 42
flottant = 3.14
# Problèmes de précision
print(0.1 + 0.2) # 0.30000000000000004
# Solutions
from decimal import Decimal
Decimal('0.1') + Decimal('0.2') # 0.3
2. Chaînes de caractères avancées (10 min)
python
# Méthodes essentielles
texte = " Python "
print([Link]().upper()) # "PYTHON"
# Recherche et remplacement
email = "user@[Link]"
print([Link]("@")) # 4
3. Formatage avancé des strings (7 min)
python
# F-strings (recommandé)
nom = "Alice"
age = 25
print(f"Je m'appelle {nom} et j'ai {age} ans")
# Formatage numérique
salaire = 45000.5678
print(f"Salaire: {salaire:,.2f}€") # 45 000,57€
B. Variables et gestion mémoire (15 min)
1. Règles de nommage et conventions (5 min)
python
# PEP 8 conventions
variable_snake_case = "valide"
CONSTANTE_MAJUSCULES = "immutable"
# ❌ À éviter
123variable = "invalide"
ma-variable = "invalide"
2. Affectation et références (5 min)
python
# Références vs copies
liste1 = [1, 2, 3]
liste2 = liste1 # Référence
liste3 = [Link]() # Copie
3. Types mutables vs immutables (5 min)
python
# Immutables (ne changent pas)
x = 10
y = "hello"
# Mutables (peuvent changer)
liste = [1, 2, 3]
[Link](4) # Modifié en place
C. Opérateurs complets (20 min)
1. Opérateurs arithmétiques avancés (6 min)
python
a, b = 17, 5
print(a // b) # Division entière: 3
print(a % b) # Modulo: 2
print(a ** b) # Puissance: 1419857
2. Opérateurs de comparaison et logiques (7 min)
python
# Comparaisons chaînées
age = 25
print(18 <= age <= 65) # True
# Court-circuit logique
result = False and fonction_couteuse() # Fonction non appelée
3. Opérateurs d'appartenance et d'identité (7 min)
python
fruits = ["pomme", "banane"]
print("pomme" in fruits) # True
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b) # True (contenu égal)
print(a is b) # False (objets différents)
Module 3: Collections de données approfondies (1h15)
A. Listes - Maîtrise complète (30 min)
1. Création et initialisation avancées (8 min)
python
# Différentes méthodes de création
liste_vide = []
liste_directe = [1, 2, 3]
liste_range = list(range(5))
2. Indexation et slicing avancés (10 min)
python
liste = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(liste[2:5]) # [2, 3, 4]
print(liste[::-1]) # Inversion [9, 8, ..., 0]
3. Méthodes et opérations complètes (12 min)
python
fruits = ["pomme", "banane"]
[Link]("orange")
[Link](1, "kiwi")
[Link](["mangue", "ananas"])
# Tri et recherche
[Link]()
print([Link]("pomme"))
B. Dictionnaires - Maîtrise complète (30 min)
1. Création et manipulation avancées (12 min)
python
# Création de dictionnaires
personne = {"nom": "Alice", "age": 25}
personne2 = dict(nom="Bob", age=30)
# Dictionary comprehension
carres = {x: x**2 for x in range(5)}
2. Accès et modification sécurisés (8 min)
python
# Accès sécurisé
age = [Link]("age", 0) # 0 si clé absente
[Link]("ville", "Paris")
3. Méthodes et itération avancées (10 min)
python
for cle, valeur in [Link]():
print(f"{cle}: {valeur}")
# Tri par valeurs
trié = dict(sorted([Link](), key=lambda x: x[1]))
C. Tuples et structures avancées (15 min)
1. Tuples et immutabilité (8 min)
python
coordonnees = (10, 20)
x, y = coordonnees # Unpacking
# Unpacking avancé
premier, *reste, dernier = (1, 2, 3, 4, 5)
2. Collections avancées (7 min)
python
# Sets (ensembles uniques)
fruits = {"pomme", "banane", "pomme"} # {"pomme", "banane"}
# NamedTuple
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
Module 4: Fonctions et programmation structurée (1h15)
A. Fonctions complètes (40 min)
1. Définition et paramètres avancés (15 min)
python
def saluer(nom, titre="M./Mme"):
return f"Bonjour {titre} {nom} !"
# Arguments variables
def moyenne(*notes):
return sum(notes) / len(notes) if notes else 0
2. Fonctions avancées et closures (12 min)
python
# Fonctions comme objets
def créateur_multiplicateur(facteur):
def multiplicateur(x):
return x * facteur
return multiplicateur
double = créateur_multiplicateur(2)
3. Documentation et annotations (13 min)
python
def calculer_stats(données):
"""
Calcule les statistiques descriptives.
Args:
données: Liste de nombres
Returns:
dict: Statistiques calculées
"""
# Implémentation...
pass
B. Gestion des erreurs et bonnes pratiques (35 min)
1. Gestion complète des exceptions (20 min)
python
try:
résultat = x / y
except ZeroDivisionError:
print("Division par zéro impossible")
except Exception as e:
print(f"Erreur inattendue: {e}")
else:
print("Succès")
finally:
print("Nettoyage")
2. Organisation du code et bonnes pratiques (15 min)
python
# Structure modulaire
#!/usr/bin/env python3
"""
Module bien documenté
"""
import modules_necessaires
CONSTANTES = "en majuscules"
def fonctions_principales():
"""Documentation claire."""
pass
if __name__ == "__main__":
# Code d'exécution principal
pass
Module 5: Pandas pour l'analyse de données (1h)
A. Installation et premiers pas avec Pandas (15 min)
1. Installation et configuration (5 min)
python
import pandas as pd
import numpy as np
print(f"Pandas version: {pd.__version__}")
2. Structure des DataFrames et Series (10 min)
python
# Création de Series et DataFrame
s = [Link]([1, 2, 3, 4, 5])
df = [Link]({
'nom': ['Alice', 'Bob'],
'age': [25, 30],
'ville': ['Paris', 'Lyon']
})
B. Lecture et écriture de fichiers (20 min)
1. Lecture de fichiers CSV avancée (12 min)
python
# Lecture avec paramètres
df = pd.read_csv('[Link]',
encoding='utf-8',
sep=';',
na_values=['', 'NULL'])
2. Lecture de fichiers Excel et autres formats (8 min)
python
df_excel = pd.read_excel('[Link]', sheet_name='Feuille1')
df.to_csv('[Link]', index=False)
C. Exploration et nettoyage des données (25 min)
1. Exploration des données (12 min)
python
print([Link]())
print([Link]())
print([Link]())
print(df['colonne'].value_counts())
2. Nettoyage des données (13 min)
python
# Gestion des valeurs manquantes
df_clean = [Link]()
df_filled = [Link](method='ffill')
# Suppression des doublons
df_unique = df.drop_duplicates()
# Conversion de types
df['date'] = pd.to_datetime(df['date_col'])
D. Opérations avancées et analyse (25 min)
1. Sélection et filtrage avancés (10 min)
python
# Filtrage conditionnel
jeunes = df[df['age'] < 30]
parisiens = df[df['ville'] == 'Paris']
# Query avancée
resultats = [Link]("age > 25 and ville == 'Paris'")
2. Groupement et agrégation (10 min)
python
# GroupBy avec agrégations
stats = [Link]('ville')['age'].agg(['mean', 'count', 'std'])
# Pivot tables
pivot = df.pivot_table(values='age', index='ville', aggfunc='mean')
3. Manipulation et création de colonnes (8 min)
python
# Nouvelles colonnes
df['age_carré'] = df['age'] ** 2
df['catégorie'] = [Link](df['age'] > 30, 'Senior', 'Junior')
# Opérations par ligne
df['nom_complet'] = df['prenom'] + ' ' + df['nom']
Exercices pratiques et projets (30 min)
Exercice 1: Analyse de données étudiantes (15 min)
Objectif : Analyser un dataset d'étudiants avec Pandas
Exercice 2: Projet de recommandation (15 min)
Objectif : Créer un système de recommandation basique
Ressources et documentation (5 min bonus)
Ressources recommandées :
Documentation officielle Python
Pandas documentation