Plan Python — Maîtriser les bases

Exercices progressifs · Mini-projets · Pédagogie active

Rythme conseillé : 2 à 3h par jour · 5 semaines

Comment utiliser ce plan

→ Fais les exercices dans l'ordre — chaque notion prépare la suivante
→ Ne passe pas au suivant avant d'avoir compris le précédent
→ Chaque vendredi = mini-projet qui assemble tout ce que tu as appris
→ Règle d'or : 20% lecture, 80% code — sans exception

SEMAINE 1 — Bases du langage Python

Objectif : à la fin de cette semaine, tu écris des programmes qui lisent des données, font des
calculs, prennent des décisions et répètent des actions.

BLOC 1 — Variables, types et opérations

Avant de commencer : installe Python 3 et VS Code. Dans le terminal : python3 --version

Exercice 1.1 — Calculatrice basique

Consigne Écris un programme qui demande deux nombres à l'utilisateur avec input(), les
convertit en float, puis affiche leur somme, différence, produit et quotient.
Règles → Utiliser input() pour lire
→ Convertir avec float()
→ Gérer la division par zéro avec if
→ Afficher avec print() et f-strings : f'Résultat : {val}'

Bonus Ajouter la puissance et le modulo

Exercice 1.2 — Convertisseur d'unités

Consigne Écris un programme qui convertit des températures Celsius → Fahrenheit →
Kelvin. Formules : F = C * 9/5 + 32, K = C + 273.15
Règles → Lire la température en Celsius avec input()
→ Calculer et afficher les 3 valeurs
→ Afficher avec 2 décimales : f'{val:.2f}'
 Exercice 1.3 — Détecteur de type
Consigne Écris une fonction detect_type(val) qui reçoit une valeur et retourne son type sous
forme de string : 'entier', 'flottant', 'string', 'booléen', 'autre'.
Règles → Utiliser isinstance(val, int), isinstance(val, float)...
→ Attention : bool est une sous-classe de int — tester bool EN PREMIER
→ Tester avec : 42, 3.14, 'hello', True, [1,2,3]

BLOC 2 — Conditions et boucles

Exercice 2.1 — FizzBuzz

Consigne Affiche les nombres de 1 à 100. Mais : pour les multiples de 3 affiche 'Fizz', pour
les multiples de 5 affiche 'Buzz', pour les multiples des deux affiche 'FizzBuzz'.
Règles → Utiliser l'opérateur modulo %
→ Tester le cas FizzBuzz EN PREMIER (avant Fizz et Buzz)
→ Utiliser range(1, 101)

Bonus Rendre n paramétrable : fizzbuzz(n) avec n en argument

Exercice 2.2 — Table de multiplication

Consigne Écris un programme qui affiche la table de multiplication d'un nombre demandé à
l'utilisateur, de 1 à 10.
Règles → Utiliser une boucle for avec range(1, 11)
→ Afficher proprement : f'{n} x {i} = {n*i}'
→ Tester avec n=7

Exercice 2.3 — Devine le nombre

Consigne Génère un nombre aléatoire entre 1 et 100 avec [Link](1, 100).
Demande à l'utilisateur de deviner. Dis 'Trop grand', 'Trop petit' ou 'Bravo!' et
compte le nombre d'essais.
Règles → import random en haut du fichier
→ Utiliser une boucle while True avec break quand trouvé
→ Afficher le nombre d'essais à la fin

Bonus Limiter à 7 essais maximum (c'est mathématiquement toujours suffisant)

Exercice 2.4 — Vérificateur de mot de passe

Consigne Écris is_strong_password(pwd) qui retourne True si le mot de passe a : au moins
8 caractères, au moins 1 majuscule, 1 minuscule, 1 chiffre.
Règles → Utiliser les méthodes : any(), isupper(), islower(), isdigit()
→ any([Link]() for c in pwd) vérifie s'il y a au moins 1 majuscule
→ Retourner False dès qu'une condition échoue

BLOC 3 — Fonctions

Exercice 3.1 — Fonctions mathématiques

Consigne Écris ces fonctions : ft_abs(n), ft_max(a,b), ft_min(a,b), ft_power(base, exp) sans
utiliser les fonctions built-in abs(), max(), min(), pow().
Règles → Pas d'import math
→ ft_power avec une boucle (pas l'opérateur **)
→ Tester chaque fonction avec au moins 3 cas

Exercice 3.2 — Palindrome et anagramme

Consigne Écris is_palindrome(s) qui retourne True si s est un palindrome. Écris
is_anagram(s1, s2) qui retourne True si s1 et s2 sont des anagrammes.
Règles → Palindrome : 'racecar', 'level', 'A man a plan a canal Panama' (ignorer espaces et
casse)
→ Anagramme : 'listen' et 'silent', 'hello' et 'world' (False)
→ Utiliser [Link]() et [Link](' ', '') pour normaliser

Bonus Gérer les accents avec [Link]()

Exercice 3.3 — Statistiques

Consigne Écris ces fonctions sur une liste de nombres : ft_mean(lst), ft_median(lst),
ft_mode(lst) — sans utiliser statistics ou numpy.
Règles → ft_mean : somme / longueur
→ ft_median : trier la liste, prendre l'élément du milieu
→ ft_mode : l'élément qui apparaît le plus souvent

MINI-PROJET 1 — Mini calculatrice scientifique

Sujet Crée un programme interactif avec un menu : 1) Opérations de base, 2)
Conversions (temp, km/miles, kg/lbs), 3) Statistiques sur une liste de nombres, 4)
Quitter. L'utilisateur peut faire plusieurs opérations sans relancer le programme.
Livrable ✓ Menu qui tourne en boucle jusqu'à 'Quitter'
✓ Toutes les fonctions dans un fichier séparé [Link]
✓ Gestion des erreurs : division par zéro, input invalide (try/except)
✓ Au moins 3 conversions disponibles
 Contraintes → Pas de bibliothèques externes
→ Fonctions réutilisables — pas de code dupliqué
→ Code lisible : noms de variables clairs, commentaires sur les parties complexes

SEMAINE 2 — Structures de données

Objectif : maîtriser listes, dictionnaires, tuples et sets — savoir quand utiliser quoi.

BLOC 4 — Listes

Exercice 4.1 — Manipulation de listes

Consigne Écris ces fonctions sans utiliser les méthodes built-in correspondantes :
ft_flatten(lst) aplatit une liste de listes, ft_unique(lst) retourne les éléments
uniques, ft_chunk(lst, n) découpe en morceaux de taille n.
Règles → ft_flatten([[1,2],[3,4]]) → [1,2,3,4]
→ ft_unique([1,2,2,3,1]) → [1,2,3] (garder l'ordre)
→ ft_chunk([1,2,3,4,5], 2) → [[1,2],[3,4],[5]]

Exercice 4.2 — List comprehensions

Consigne Réécris ces opérations en une seule ligne avec des list comprehensions : 1)
carré des nombres pairs de 1 à 20, 2) mots de plus de 4 lettres d'une phrase, 3)
matrice 4x4 remplie de zéros.
Règles → [x**2 for x in range(...) if ...]
→ Pas de boucle for classique — tout en une ligne
→ Tester chaque résultat avec print()

Exercice 4.3 — Tris personnalisés

Consigne Trie une liste de dictionnaires représentant des étudiants [{nom, age, note}] : 1)
par note décroissante, 2) par nom alphabétique, 3) par age puis note.
Règles → Utiliser sorted() avec key=lambda
→ sorted(lst, key=lambda x: x['note'], reverse=True)
→ Ne pas modifier la liste originale — sorted() retourne une nouvelle liste

BLOC 5 — Dictionnaires & Sets

 Exercice 5.1 — Compteur de mots
Consigne Écris word_count(text) qui retourne un dictionnaire avec chaque mot et son
nombre d'occurrences dans le texte. Ignorer la casse et la ponctuation.
Règles → [Link]() puis remplacer la ponctuation
→ Utiliser [Link](mot, 0) + 1 pour compter
→ Retourner le dict trié par fréquence décroissante (sorted + dict())

Bonus Trouver les 5 mots les plus fréquents

Exercice 5.2 — Opérations sur les sets

Consigne Écris des fonctions qui, à partir de deux listes, retournent : les éléments
communs, les éléments uniquement dans la première, les éléments dans l'une
OU l'autre mais pas les deux.
Règles → Convertir les listes en sets avec set()
→ Intersection : & ou .intersection()
→ Différence symétrique : ^ ou .symmetric_difference()
→ Retourner des listes triées (list(sorted(...)))

Exercice 5.3 — Carnet de contacts (dict)

Consigne Implémente un carnet de contacts avec un dictionnaire. Fonctions :
add_contact(name, phone, email), get_contact(name), delete_contact(name),
search_by_phone(phone), export_to_list().
Règles → Stocker : contacts = {} avec name comme clé
→ get_contact retourne None si pas trouvé (pas d'erreur)
→ search_by_phone parcourt tous les contacts
→ export_to_list() retourne une liste de dicts triée par nom

BLOC 6 — Tuples, enumerate, zip

Exercice 6.1 — Traitement de données tabulaires

Consigne Tu as des données : etudiants = [('Alice', 85), ('Bob', 72), ('Charlie', 91)]. Écris des
fonctions : get_ranking() retourne le classement avec rang, get_average(),
get_above_average().
Règles → Utiliser enumerate(sorted(...), 1) pour le rang
→ zip() pour combiner deux listes
→ Tuple unpacking : for nom, note in etudiants:
 Exercice 6.2 — Décompresseur de données
Consigne Écris unzip(pairs) qui transforme [(1,'a'),(2,'b'),(3,'c')] en ([1,2,3], ['a','b','c']). Écris
transpose(matrix) qui transpose une matrice 2D.
Règles → unzip avec zip(*pairs) — le * dépaque la liste
→ transpose : zip(*matrix) transforme lignes en colonnes
→ Retourner des tuples de listes

MINI-PROJET 2 — Analyseur de données CSV

Sujet Crée un programme qui lit un fichier CSV d'étudiants (nom, age, note_maths,
note_info, note_anglais), stocke tout dans une liste de dicts, et propose :
moyenne par matière, classement général, étudiants en difficulté (moyenne <
10), export des résultats dans un nouveau CSV.
Livrable ✓ Lire le CSV avec le module csv de la librairie standard
✓ Stocker dans une liste de dictionnaires
✓ Calculer les moyennes par matière et générale
✓ Afficher un classement numéroté
✓ Écrire les résultats dans [Link]

Contraintes → Pas de pandas — utiliser uniquement csv et les structures natives

→ Gérer le cas fichier inexistant avec try/except
→ Fonctions séparées pour chaque opération

SEMAINE 3 — Fichiers, Modules & Programmation

Orientée Objet
Objectif : lire/écrire des fichiers, organiser son code en modules, créer ses propres classes.

BLOC 7 — Fichiers & gestion d'erreurs

Exercice 7.1 — Lecteur de fichiers

Consigne Écris ces fonctions : read_lines(path) retourne une liste de lignes,
count_words(path) compte les mots, find_in_file(path, word) retourne les
numéros de lignes contenant word.
Règles → Toujours utiliser with open(path, 'r') as f — ferme automatiquement
→ Gérer FileNotFoundError avec try/except
→ strip() pour enlever \n en fin de ligne
Bonus Ajouter search_and_replace(path, old, new) qui réécrit le fichier

Exercice 7.2 — Gestionnaire de logs

Consigne Écris un logger simple : log(message, level='INFO') écrit dans un fichier [Link]
avec timestamp et niveau. Niveaux : INFO, WARNING, ERROR. get_errors()
retourne toutes les lignes ERROR.
Règles → from datetime import datetime — [Link]().strftime('%Y-%m-%d %H:%M:%S')
→ Ouvrir en mode 'a' (append) pour ne pas écraser
→ Format : '2024-01-15 14:32:01 [ERROR] message'

Exercice 7.3 — Sérialization JSON

Consigne Écris save_data(data, path) qui sauvegarde n'importe quelle structure Python en
JSON. Écris load_data(path) qui la recharge. Tester avec une liste de contacts.
Règles → import json
→ [Link](data, f, indent=2) pour un JSON lisible
→ [Link](f) pour relire
→ Gérer JSONDecodeError si le fichier est corrompu

BLOC 8 — Programmation Orientée Objet

Exercice 8.1 — Classe Etudiant

Consigne Crée une classe Etudiant avec : attributs (nom, age, notes), méthodes
add_note(note), get_average(), get_mention() (Bien/Assez
bien/Passable/Insuffisant), __str__ pour l'affichage.
Règles → __init__(self, nom, age) — notes = [] vide au départ
→ add_note vérifie que la note est entre 0 et 20
→ get_mention utilise if/elif sur la moyenne
→ __str__ retourne une string lisible : f'Etudiant: {[Link]}, Moyenne:
{self.get_average():.1f}'

Exercice 8.2 — Classe BankAccount

Consigne Crée une classe BankAccount : attributs (owner, balance, transactions),
méthodes deposit(amount), withdraw(amount), get_history(), __str__.
Règles → withdraw lève ValueError si solde insuffisant
→ transactions = [] stocke chaque opération avec montant et type
→ get_history() retourne les 10 dernières transactions
→ balance ne peut jamais être négatif
 Exercice 8.3 — Héritage — Zoo
Consigne Crée une classe Animal(nom, age) avec une méthode speak() abstraite. Crée
Dog, Cat, Bird qui héritent d'Animal et implémentent speak(). Crée une classe
Zoo qui gère une liste d'animaux.
Règles → from abc import ABC, abstractmethod
→ class Dog(Animal) : super().__init__(nom, age) dans __init__
→ Zoo.add_animal(animal), Zoo.make_all_speak(), Zoo.get_by_type(type)

Bonus Ajouter __repr__ et __len__ à la classe Zoo

MINI-PROJET 3 — Gestionnaire de bibliothèque

Sujet Crée un système de gestion de bibliothèque avec POO. Classes : Book(titre,
auteur, isbn, disponible), Member(nom, id, livres_empruntes), Library(books,
members). Fonctions : emprunter, retourner, rechercher par auteur/titre,
sauvegarder/charger depuis JSON.
Livrable ✓ Classe Book avec __str__ et __repr__
✓ Classe Member avec historique des emprunts
✓ Classe Library avec toutes les opérations
✓ Sauvegarde automatique dans [Link] à chaque modification
✓ Chargement au démarrage si le fichier existe

Contraintes → Utiliser @property pour les attributs en lecture seule

→ Lever des exceptions appropriées (BookNotAvailable, MemberNotFound)
→ Pas de code dupliqué — factoriser les opérations communes

SEMAINE 4 — Algorithmique & Structures de

données avancées
Objectif : implémenter les algorithmes classiques, analyser leur complexité, choisir la bonne
structure pour chaque problème.

BLOC 9 — Récursivité

Exercice 9.1 — Classiques récursifs

Consigne Écris en récursif : factorial(n), fibonacci(n), power(base, exp), sum_digits(n)
(somme des chiffres de n), reverse_string(s).
Règles → Définir le cas de base AVANT le cas récursif
 → factorial(0) = 1, fibonacci(0)=0 fibonacci(1)=1
→ sum_digits(123) = 1+2+3 = 6 : sum_digits(n//10) + n%10

Bonus Comparer fibonacci récursif vs itératif pour n=35 avec [Link]()

Exercice 9.2 — Tours de Hanoï

Consigne Implémente hanoi(n, source, destination, auxiliaire) qui affiche chaque
mouvement. Compte le nombre de mouvements et vérifie que c'est toujours 2^n -
1.
Règles → Cas de base : n == 1 → afficher le mouvement direct
→ Cas récursif : déplacer n-1 vers auxiliaire, puis 1 vers dest, puis n-1 vers dest
→ Compter avec une variable globale ou un return cumulé

Exercice 9.3 — Recherche binaire récursive

Consigne Implémente binary_search(lst, target, low=0, high=None) qui cherche target dans
une liste TRIÉE. Retourner l'index si trouvé, -1 sinon.
Règles → Cas de base : low > high → -1 (pas trouvé)
→ mid = (low + high) // 2
→ Si lst[mid] == target → retourner mid
→ Si lst[mid] < target → chercher dans la moitié droite

Bonus Comparer avec une recherche linéaire sur 1 million d'éléments — mesurer le temps

BLOC 10 — Algorithmes de tri

Exercice 10.1 — Tris O(n²)

Consigne Implémente bubble_sort(lst), selection_sort(lst), insertion_sort(lst) sans utiliser
sort() ou sorted(). Chaque fonction retourne une NOUVELLE liste triée.
Règles → Ne pas modifier la liste originale : travailler sur [Link]()
→ Bubble sort : comparer adjacents, faire remonter les grands
→ Selection sort : trouver le min, le placer en position i
→ Insertion sort : insérer chaque élément à sa bonne place dans la partie triée

Bonus Ajouter un compteur d'opérations et comparer les 3 sur 1000 éléments

Exercice 10.2 — Merge Sort — O(n log n)

Consigne Implémente merge_sort(lst) récursivement. Divise la liste en deux, trie chaque
moitié, fusionne.
 Règles → Cas de base : len(lst) <= 1 → retourner lst
→ mid = len(lst) // 2
→ left = merge_sort(lst[:mid])
→ Fonction merge(left, right) qui fusionne deux listes triées

Bonus Implémenter aussi quick_sort(lst) et comparer les deux sur 100 000 éléments

Exercice 10.3 — Benchmark

Consigne Génère une liste de 10 000 entiers aléatoires. Compare le temps d'exécution de
tes 4 tris + sorted() Python. Affiche un tableau de résultats.
Règles → import random, time
→ [Link](range(100000), 10000) — liste sans doublons
→ [Link]() avant et après chaque tri
→ Trier UNE COPIE pour chaque algo : [Link]()

MINI-PROJET 4 — Moteur de recherche de contacts

Sujet Reprends ton carnet de contacts (mini-projet 2). Ajoute : recherche par préfixe
(autocomplete), tri par différents critères, recherche floue (un contact même si le
nom est mal orthographié), export JSON et CSV, statistiques (age moyen,
distribution par lettre).
Livrable ✓ Recherche par préfixe avec list comprehension
✓ Tri avec sorted() et lambda
✓ Recherche floue avec [Link]
✓ Export dans les deux formats
✓ Affichage des stats formaté proprement

Contraintes → Utiliser la classe Contact (POO) pour chaque contact

→ Tester avec au moins 50 contacts générés aléatoirement
→ Mesurer le temps de chaque recherche

SEMAINE 5 — Automatisation & Introduction au

Web
Objectif : automatiser des tâches réelles et créer une première application web avec Flask.

BLOC 11 — Automatisation
 Exercice 11.1 — Organisateur de fichiers
Consigne Écris un script qui organise automatiquement les fichiers d'un dossier par type :
PDF → /docs, images (jpg,png,gif) → /images, code (py,js,html) → /code, autres
→ /misc.
Règles → import os, shutil
→ [Link](path) pour lister les fichiers
→ [Link](f) pour l'extension
→ [Link](src, dst) pour déplacer
→ [Link](path, exist_ok=True) pour créer les dossiers

Bonus Ajouter un log des fichiers déplacés avec timestamp

Exercice 11.2 — Scraper de données

Consigne Écris un script qui récupère les titres et prix depuis une URL de test :
[Link] — stocke les données dans un CSV.
Règles → pip install requests beautifulsoup4
→ [Link](url).text pour le HTML
→ BeautifulSoup(html, '[Link]')
→ soup.find_all('article', class_='product_pod')
→ Écrire dans CSV avec [Link]

Exercice 11.3 — Envoi d'emails automatique

Consigne Écris send_report(to, subject, body, csv_path) qui envoie un email avec un fichier
CSV en pièce jointe via SMTP Gmail.
Règles → import smtplib, ssl, [Link]
→ Utiliser un mot de passe d'application Gmail (pas le vrai mot de passe)
→ MIMEMultipart pour le corps + pièce jointe
→ Stocker les credentials dans un fichier .env — jamais en dur dans le code

BLOC 12 — Introduction Flask (Web)

Exercice 12.1 — Première API REST

Consigne Crée une API Flask avec ces routes : GET /contacts → liste tous les contacts,
GET /contacts/<id> → un contact, POST /contacts → créer, DELETE
/contacts/<id> → supprimer.
Règles → pip install flask
→ from flask import Flask, jsonify, request
→ Stocker les contacts dans une liste en mémoire (pas de DB)
→ jsonify() pour retourner du JSON
→ Tester avec curl ou l'extension REST Client de VS Code
 Exercice 12.2 — Interface web simple
Consigne Ajoute des templates HTML à ton API Flask : page d'accueil qui liste les contacts,
formulaire pour en ajouter un, bouton supprimer.
Règles → pip install flask
→ render_template('[Link]') retourne une page HTML
→ Créer un dossier templates/ avec tes fichiers HTML
→ {{ [Link] }} dans le HTML pour afficher les données
→ url_for('add_contact') pour les liens

MINI-PROJET FINAL — Application web de gestion de tâches

Sujet Crée une application web complète avec Flask : liste de tâches avec titre,
description, priorité (1-5), statut (todo/en cours/fait), date d'échéance.
Fonctionnalités : CRUD complet, filtrage par statut/priorité, marquage comme fait,
sauvegarde en JSON, interface web avec HTML/CSS.
Livrable ✓ Backend Flask avec toutes les routes CRUD
✓ Sauvegarde automatique en JSON
✓ Interface HTML avec formulaire d'ajout
✓ Filtrage par statut et priorité
✓ Affichage coloré selon la priorité
✓ [Link] avec instructions d'installation

Contraintes → pip install flask — c'est la seule dépendance externe

→ Code organisé : [Link], [Link], templates/
→ Pas de base de données — JSON suffit
→ L'application doit tourner avec : python [Link]

Checklist finale — Tu maîtrises Python si...

→ Tu écris une fonction en moins de 2 minutes sans chercher la syntaxe
→ Tu choisis instinctivement entre liste, dict, set et tuple selon le contexte
→ Tu lis un fichier CSV, le traites et l'exportes sans aide
→ Tu crées une classe avec héritage et tu l'utilises dans un vrai programme
→ Tu implémentes bubble sort et merge sort de mémoire
→ Tu crées une route Flask qui retourne du JSON en moins de 10 minutes
→ Tu automatises une tâche répétitive avec un script Python

Si tu passes tous ces points : tu as une vraie base Python solide. La prochaine étape sera Django,
FastAPI, pandas ou machine learning — selon tes objectifs.