Quand j’ai commencé à enseigner Python à mes étudiants en BTS SIO, j’ai vite constaté un problème récurrent : ils comprenaient la théorie, mais restaient bloqués dès qu’il fallait coder un projet de zéro. La solution ? Passer directement à la pratique avec des projets concrets, progressifs et suffisamment motivants pour donner envie de continuer.

Python est aujourd’hui le langage le plus recommandé pour débuter en programmation. Sa syntaxe lisible, sa communauté massive et ses domaines d’application variés en font un choix évident. Mais lire des tutoriels ne suffit pas : c’est en codant qu’on apprend vraiment. Dans cet article, je vous propose 10 projets Python pour débutants, classés par difficulté croissante, avec le code source commenté pour chacun. Que vous prépariez le BTS SIO ou que vous appreniez Python en autodidacte, ces projets vous permettront de construire des compétences solides et un portfolio concret.

Pourquoi apprendre Python par projets

La pédagogie par projets n’est pas un effet de mode. Les études en sciences de l’éducation montrent que la rétention d’information passe de 10 % (lecture passive) à 75 % (pratique active). En programmation, cette différence est encore plus marquée : comprendre une boucle for dans un cours et l’utiliser pour parcourir un fichier CSV sont deux compétences très différentes.

Voici ce que chaque projet vous apportera concrètement :

• La résolution de problèmes : chaque projet pose un problème réel que vous devez décomposer en étapes logiques
• La lecture de documentation : vous apprendrez à chercher dans la doc officielle Python plutôt que de copier du code sans comprendre
• Le débogage : corriger ses propres erreurs est la compétence la plus précieuse qu’un développeur puisse acquérir
• La confiance : terminer un projet fonctionnel, même simple, donne l’élan nécessaire pour attaquer le suivant

Pour suivre ces projets, vous aurez besoin de Python 3.10 ou supérieur et d’un éditeur de code. Je recommande VS Code avec l’extension Python de Microsoft, qui offre l’autocomplétion et le débogage intégré. Si vous débutez complètement, installez Python depuis python.org et vérifiez l’installation avec python --version dans votre terminal.

Tableau récapitulatif des 10 projets

Avant de plonger dans le code, voici une vue d’ensemble des 10 projets. Ce tableau vous aidera à choisir par lequel commencer selon votre niveau actuel et les notions que vous souhaitez travailler.

Projets niveau découverte (1 à 4)

Ces quatre premiers projets sont conçus pour les vrais débutants. Ils utilisent uniquement les bases du langage : variables, conditions, boucles, fonctions et manipulation de fichiers. Aucune bibliothèque externe n’est nécessaire.

Projet 1 : Générateur de mots de passe sécurisés

Ce premier projet est parfait pour se lancer. L’objectif : créer un programme qui génère des mots de passe aléatoires selon des critères choisis par l’utilisateur (longueur, types de caractères). C’est un projet utile au quotidien qui introduit les modules random et string de la bibliothèque standard.

import random
import string

def generer_mot_de_passe(longueur=12, majuscules=True, chiffres=True, symboles=True):
    """Génère un mot de passe aléatoire selon les critères donnés."""
    caracteres = string.ascii_lowercase
    mot_de_passe_obligatoire = [random.choice(string.ascii_lowercase)]

    if majuscules:
        caracteres += string.ascii_uppercase
        mot_de_passe_obligatoire.append(random.choice(string.ascii_uppercase))
    if chiffres:
        caracteres += string.digits
        mot_de_passe_obligatoire.append(random.choice(string.digits))
    if symboles:
        caracteres += string.punctuation
        mot_de_passe_obligatoire.append(random.choice(string.punctuation))

    # Compléter avec des caractères aléatoires
    reste = longueur - len(mot_de_passe_obligatoire)
    mot_de_passe_obligatoire += [random.choice(caracteres) for _ in range(reste)]

    # Mélanger pour éviter un pattern prévisible
    random.shuffle(mot_de_passe_obligatoire)
    return ''.join(mot_de_passe_obligatoire)

# Utilisation
print("=== Générateur de mots de passe ===")
nb = int(input("Combien de mots de passe ? "))
longueur = int(input("Longueur souhaitée : "))

for i in range(nb):
    print(f"  {i+1}. {generer_mot_de_passe(longueur)}")

Ce que vous apprenez : importation de modules, paramètres par défaut dans les fonctions, listes en compréhension et la méthode shuffle. Ce projet est aussi l’occasion de découvrir la notion de sécurité des mots de passe, un sujet central en cybersécurité.

Projet 2 : Jeu du nombre mystère

Un classique indémodable qui permet de maîtriser les boucles while, les conditions et la gestion des entrées utilisateur. Le programme choisit un nombre aléatoire et le joueur doit le deviner avec des indices « plus grand » ou « plus petit ».

import random

def jeu_nombre_mystere():
    """Jeu de devinette avec compteur de tentatives."""
    borne_max = 100
    nombre_secret = random.randint(1, borne_max)
    tentatives = 0
    historique = []

    print(f"\nJe pense à un nombre entre 1 et {borne_max}.")
    print("Essayez de le deviner !\n")

    while True:
        try:
            proposition = int(input("Votre proposition : "))
        except ValueError:
            print("Veuillez entrer un nombre valide.")
            continue

        tentatives += 1
        historique.append(proposition)

        if proposition < nombre_secret:
            print("C'est plus grand !")
        elif proposition > nombre_secret:
            print("C'est plus petit !")
        else:
            print(f"\nBravo ! Vous avez trouvé {nombre_secret} en {tentatives} tentatives.")
            print(f"Historique : {historique}")
            break

jeu_nombre_mystere()

Ce que vous apprenez : gestion des exceptions avec try/except, boucle infinie contrôlée par break, f-strings pour le formatage. Pour aller plus loin, ajoutez un système de meilleur score sauvegardé dans un fichier.

Projet 3 : Quiz interactif

Ce projet introduit les dictionnaires, une structure de données fondamentale en Python. Vous créez un quiz avec des questions à choix multiples, un système de score et un récapitulatif des réponses.

def lancer_quiz():
    questions = [
        {
            "question": "Quel mot-clé Python permet de définir une fonction ?",
            "choix": ["A. func", "B. def", "C. function", "D. define"],
            "reponse": "B"
        },
        {
            "question": "Quel type Python est immuable ?",
            "choix": ["A. list", "B. dict", "C. tuple", "D. set"],
            "reponse": "C"
        },
        {
            "question": "Comment afficher du texte en Python 3 ?",
            "choix": ["A. echo()", "B. print()", "C. write()", "D. display()"],
            "reponse": "B"
        },
        {
            "question": "Quel opérateur vérifie l'égalité en Python ?",
            "choix": ["A. =", "B. ==", "C. ===", "D. eq()"],
            "reponse": "B"
        },
        {
            "question": "Quelle méthode ajoute un élément à une liste ?",
            "choix": ["A. add()", "B. push()", "C. append()", "D. insert()"],
            "reponse": "C"
        }
    ]

    score = 0
    total = len(questions)

    print("=== Quiz Python ===")
    for i, q in enumerate(questions, 1):
        print(f"\nQuestion {i}/{total} : {q['question']}")
        for choix in q["choix"]:
            print(f"  {choix}")

        reponse = input("Votre réponse : ").upper().strip()
        if reponse == q["reponse"]:
            print("Correct !")
            score += 1
        else:
            print(f"Faux. La bonne réponse était {q['reponse']}.")

    pourcentage = (score / total) * 100
    print(f"\nScore final : {score}/{total} ({pourcentage:.0f}%)")

lancer_quiz()

Ce que vous apprenez : listes de dictionnaires, itération avec enumerate, méthodes de chaînes (upper, strip). Ce projet se prête parfaitement à une extension : charger les questions depuis un fichier JSON externe pour séparer les données du code.

Projet 4 : Gestionnaire de tâches en ligne de commande

Premier projet un peu plus ambitieux : un gestionnaire de tâches complet avec les opérations CRUD (Create, Read, Update, Delete) et une sauvegarde persistante en JSON. Ce type de projet est très apprécié en gestion de projets informatiques.

import json
import os
from datetime import datetime

FICHIER = "taches.json"

def charger_taches():
    if os.path.exists(FICHIER):
        with open(FICHIER, "r", encoding="utf-8") as f:
            return json.load(f)
    return []

def sauvegarder_taches(taches):
    with open(FICHIER, "w", encoding="utf-8") as f:
        json.dump(taches, f, ensure_ascii=False, indent=2)

def ajouter_tache(taches):
    description = input("Description de la tâche : ")
    tache = {
        "id": len(taches) + 1,
        "description": description,
        "fait": False,
        "date_creation": datetime.now().strftime("%Y-%m-%d %H:%M")
    }
    taches.append(tache)
    sauvegarder_taches(taches)
    print(f"Tâche #{tache['id']} ajoutée.")

def afficher_taches(taches):
    if not taches:
        print("Aucune tâche enregistrée.")
        return
    for t in taches:
        statut = "[X]" if t["fait"] else "[ ]"
        print(f"  {statut} #{t['id']} - {t['description']} ({t['date_creation']})")

def marquer_faite(taches):
    afficher_taches(taches)
    try:
        num = int(input("Numéro de la tâche terminée : "))
        for t in taches:
            if t["id"] == num:
                t["fait"] = True
                sauvegarder_taches(taches)
                print(f"Tâche #{num} marquée comme terminée.")
                return
        print("Tâche introuvable.")
    except ValueError:
        print("Numéro invalide.")

def supprimer_tache(taches):
    afficher_taches(taches)
    try:
        num = int(input("Numéro de la tâche à supprimer : "))
        taches[:] = [t for t in taches if t["id"] != num]
        sauvegarder_taches(taches)
        print(f"Tâche #{num} supprimée.")
    except ValueError:
        print("Numéro invalide.")

def main():
    taches = charger_taches()
    while True:
        print("\n=== Gestionnaire de tâches ===")
        print("1. Afficher les tâches")
        print("2. Ajouter une tâche")
        print("3. Marquer comme faite")
        print("4. Supprimer une tâche")
        print("5. Quitter")
        choix = input("\nChoix : ")
        if choix == "1": afficher_taches(taches)
        elif choix == "2": ajouter_tache(taches)
        elif choix == "3": marquer_faite(taches)
        elif choix == "4": supprimer_tache(taches)
        elif choix == "5": break
        else: print("Choix invalide.")

main()

Ce que vous apprenez : manipulation de fichiers JSON, opérations CRUD, menu interactif, formatage de dates. Ce projet pose les bases de tout ce que vous ferez plus tard avec des bases de données et des requêtes SQL.

Projets niveau intermédiaire (5 à 7)

Ces projets montent en complexité. Vous aborderez la programmation orientée objet, les API REST et le traitement de données. Ils correspondent au niveau attendu en deuxième année de BTS SIO option SLAM.

Projet 5 : Analyseur de texte

Cet outil analyse un texte saisi ou chargé depuis un fichier pour en extraire des statistiques : nombre de mots, fréquence des termes, phrases les plus longues. Un projet très formateur pour la manipulation de chaînes de caractères.

from collections import Counter
import re

def analyser_texte(texte):
    """Analyse un texte et retourne un dictionnaire de statistiques."""
    # Nettoyage
    mots = re.findall(r'\b[a-zàâäéèêëïîôùûüç]+\b', texte.lower())
    phrases = [p.strip() for p in re.split(r'[.!?]+', texte) if p.strip()]

    # Statistiques de base
    stats = {
        "caracteres": len(texte),
        "mots": len(mots),
        "phrases": len(phrases),
        "mots_uniques": len(set(mots)),
        "mot_moyen_longueur": round(sum(len(m) for m in mots) / max(len(mots), 1), 1)
    }

    # Mots les plus fréquents (hors mots vides)
    mots_vides = {"le", "la", "les", "de", "du", "des", "un", "une", "et",
                  "en", "à", "est", "que", "qui", "dans", "pour", "pas",
                  "sur", "ce", "il", "ne", "se", "au", "son", "avec"}
    mots_filtres = [m for m in mots if m not in mots_vides and len(m) > 2]
    stats["top_10_mots"] = Counter(mots_filtres).most_common(10)

    # Phrase la plus longue
    if phrases:
        stats["phrase_plus_longue"] = max(phrases, key=len)

    return stats

# Utilisation
print("=== Analyseur de texte ===")
print("1. Saisir un texte")
print("2. Charger un fichier")
choix = input("Choix : ")

if choix == "2":
    chemin = input("Chemin du fichier : ")
    with open(chemin, "r", encoding="utf-8") as f:
        texte = f.read()
else:
    texte = input("Collez votre texte : ")

resultats = analyser_texte(texte)
print(f"\nCaractères : {resultats['caracteres']}")
print(f"Mots : {resultats['mots']}")
print(f"Mots uniques : {resultats['mots_uniques']}")
print(f"Phrases : {resultats['phrases']}")
print(f"Longueur moyenne des mots : {resultats['mot_moyen_longueur']} caractères")
print(f"\nTop 10 des mots les plus fréquents :")
for mot, freq in resultats["top_10_mots"]:
    print(f"  {mot} : {freq} occurrences")

Ce que vous apprenez : expressions régulières avec re, le module Counter de collections, filtrage de données et manipulation avancée de chaînes. Ce type de traitement est la base du traitement automatique du langage naturel (NLP).

Projet 6 : Carnet de contacts en programmation orientée objet

Ce projet introduit la POO (Programmation Orientée Objet) de manière pratique. Vous créez une classe Contact et une classe Carnet qui gère une collection de contacts avec recherche, tri et export.

import json
import os

class Contact:
    def __init__(self, nom, prenom, email, telephone=""):
        self.nom = nom
        self.prenom = prenom
        self.email = email
        self.telephone = telephone

    def __str__(self):
        return f"{self.prenom} {self.nom} | {self.email} | {self.telephone}"

    def to_dict(self):
        return {
            "nom": self.nom,
            "prenom": self.prenom,
            "email": self.email,
            "telephone": self.telephone
        }

    @classmethod
    def from_dict(cls, data):
        return cls(data["nom"], data["prenom"], data["email"], data.get("telephone", ""))


class Carnet:
    def __init__(self, fichier="contacts.json"):
        self.fichier = fichier
        self.contacts = []
        self.charger()

    def charger(self):
        if os.path.exists(self.fichier):
            with open(self.fichier, "r", encoding="utf-8") as f:
                donnees = json.load(f)
                self.contacts = [Contact.from_dict(d) for d in donnees]

    def sauvegarder(self):
        with open(self.fichier, "w", encoding="utf-8") as f:
            json.dump([c.to_dict() for c in self.contacts], f,
                      ensure_ascii=False, indent=2)

    def ajouter(self, contact):
        self.contacts.append(contact)
        self.sauvegarder()

    def rechercher(self, terme):
        terme = terme.lower()
        return [c for c in self.contacts
                if terme in c.nom.lower() or terme in c.prenom.lower()
                or terme in c.email.lower()]

    def afficher_tous(self):
        for i, c in enumerate(sorted(self.contacts, key=lambda x: x.nom), 1):
            print(f"  {i}. {c}")


# Utilisation
carnet = Carnet()
while True:
    print("\n=== Carnet de contacts ===")
    print("1. Afficher  2. Ajouter  3. Rechercher  4. Quitter")
    choix = input("Choix : ")
    if choix == "1":
        carnet.afficher_tous()
    elif choix == "2":
        c = Contact(
            input("Nom : "), input("Prénom : "),
            input("Email : "), input("Téléphone : ")
        )
        carnet.ajouter(c)
        print("Contact ajouté.")
    elif choix == "3":
        resultats = carnet.rechercher(input("Recherche : "))
        for r in resultats:
            print(f"  → {r}")
    elif choix == "4":
        break

Ce que vous apprenez : classes et objets, méthodes spéciales (__str__), décorateur @classmethod, sérialisation JSON d’objets personnalisés. La POO est une compétence essentielle pour tout développeur, et ce projet en couvre les bases de manière très concrète.

Projet 7 : Scraper météo avec API

Ce projet vous initie aux API REST en interrogeant une API météo gratuite. C’est votre première interaction avec un service web externe depuis Python. Vous aurez besoin d’installer le module requests avec pip install requests.

import requests

def obtenir_meteo(ville):
    """Récupère la météo actuelle via l'API Open-Meteo (gratuite, sans clé)."""
    # Étape 1 : géocodage de la ville
    geo_url = "https://geocoding-api.open-meteo.com/v1/search"
    geo_params = {"name": ville, "count": 1, "language": "fr"}
    geo_response = requests.get(geo_url, params=geo_params)
    geo_data = geo_response.json()

    if "results" not in geo_data:
        print(f"Ville '{ville}' introuvable.")
        return None

    lieu = geo_data["results"][0]
    lat, lon = lieu["latitude"], lieu["longitude"]
    nom_complet = f"{lieu['name']}, {lieu.get('country', '')}"

    # Étape 2 : récupération de la météo
    meteo_url = "https://api.open-meteo.com/v1/forecast"
    meteo_params = {
        "latitude": lat,
        "longitude": lon,
        "current": "temperature_2m,relative_humidity_2m,wind_speed_10m,weather_code",
        "timezone": "auto"
    }
    meteo_response = requests.get(meteo_url, params=meteo_params)
    meteo_data = meteo_response.json()["current"]

    print(f"\nMétéo pour {nom_complet}")
    print(f"  Température : {meteo_data['temperature_2m']}°C")
    print(f"  Humidité : {meteo_data['relative_humidity_2m']}%")
    print(f"  Vent : {meteo_data['wind_speed_10m']} km/h")
    return meteo_data

# Utilisation
print("=== Météo en temps réel ===")
while True:
    ville = input("\nVille (ou 'q' pour quitter) : ")
    if ville.lower() == 'q':
        break
    obtenir_meteo(ville)

Ce que vous apprenez : requêtes HTTP avec requests, paramètres d’URL, parsing de réponses JSON, chaînage d’appels API. La maîtrise des API est devenue incontournable, que ce soit pour le développement web ou l’automatisation.

Projets niveau avancé (8 à 10)

Ces trois derniers projets sont les plus complets. Ils combinent plusieurs compétences et vous préparent à des projets professionnels. Prenez le temps de bien comprendre les projets précédents avant de vous lancer ici.

Projet 8 : Convertisseur de fichiers CSV

Un outil pratique qui lit un fichier CSV, le transforme (filtrage, tri, calculs) et exporte le résultat. Ce projet est particulièrement utile si vous travaillez avec des données tabulaires ou si vous préparez des projets en lien avec les bases de données.

import csv
import os

def lire_csv(chemin):
    """Lit un fichier CSV et retourne les en-têtes et les données."""
    with open(chemin, "r", encoding="utf-8") as f:
        lecteur = csv.DictReader(f, delimiter=";")
        donnees = list(lecteur)
        en_tetes = lecteur.fieldnames
    return en_tetes, donnees

def afficher_apercu(en_tetes, donnees, n=5):
    """Affiche les n premières lignes."""
    print(f"\nColonnes : {', '.join(en_tetes)}")
    print(f"Nombre de lignes : {len(donnees)}")
    print(f"\nAperçu ({n} premières lignes) :")
    for ligne in donnees[:n]:
        print("  ", " | ".join(f"{k}: {v}" for k, v in ligne.items()))

def filtrer_donnees(donnees, colonne, valeur):
    """Filtre les lignes où colonne contient valeur."""
    return [l for l in donnees if valeur.lower() in l.get(colonne, "").lower()]

def trier_donnees(donnees, colonne, inverse=False):
    """Trie les données selon une colonne."""
    return sorted(donnees, key=lambda x: x.get(colonne, ""), reverse=inverse)

def exporter_csv(chemin, en_tetes, donnees):
    """Exporte les données dans un nouveau fichier CSV."""
    with open(chemin, "w", encoding="utf-8", newline="") as f:
        ecrivain = csv.DictWriter(f, fieldnames=en_tetes, delimiter=";")
        ecrivain.writeheader()
        ecrivain.writerows(donnees)
    print(f"Exporté vers {chemin} ({len(donnees)} lignes).")

# Programme principal
print("=== Convertisseur CSV ===")
chemin = input("Chemin du fichier CSV : ")
if not os.path.exists(chemin):
    print("Fichier introuvable.")
else:
    en_tetes, donnees = lire_csv(chemin)
    afficher_apercu(en_tetes, donnees)

    print("\nActions disponibles :")
    print("1. Filtrer  2. Trier  3. Exporter  4. Quitter")
    while True:
        choix = input("\nAction : ")
        if choix == "1":
            col = input(f"Colonne ({', '.join(en_tetes)}) : ")
            val = input("Valeur à rechercher : ")
            donnees = filtrer_donnees(donnees, col, val)
            afficher_apercu(en_tetes, donnees)
        elif choix == "2":
            col = input(f"Trier par ({', '.join(en_tetes)}) : ")
            donnees = trier_donnees(donnees, col)
            afficher_apercu(en_tetes, donnees)
        elif choix == "3":
            nom = input("Nom du fichier de sortie : ")
            exporter_csv(nom, en_tetes, donnees)
        elif choix == "4":
            break

Ce que vous apprenez : module csv avec DictReader et DictWriter, manipulation de fichiers, lambda functions pour le tri. Ce projet est un tremplin vers des outils comme pandas que vous utiliserez dans des contextes plus avancés.

Projet 9 : Jeu du pendu avec interface graphique Tkinter

Ce projet combine logique de jeu et interface graphique avec Tkinter, la bibliothèque GUI intégrée à Python. Pas besoin d’installer quoi que ce soit en plus.

import tkinter as tk
import random

MOTS = ["python", "algorithme", "variable", "fonction", "boucle",
        "condition", "dictionnaire", "module", "classe", "exception"]

class JeuPendu:
    def __init__(self, racine):
        self.racine = racine
        self.racine.title("Jeu du Pendu")
        self.mot = random.choice(MOTS)
        self.lettres_trouvees = set()
        self.erreurs = 0
        self.max_erreurs = 7

        # Affichage du mot
        self.label_mot = tk.Label(racine, text=self.afficher_mot(),
                                  font=("Courier", 28))
        self.label_mot.pack(pady=20)

        # Zone de saisie
        self.frame_saisie = tk.Frame(racine)
        self.frame_saisie.pack(pady=10)
        self.entry = tk.Entry(self.frame_saisie, width=3, font=("Arial", 18))
        self.entry.pack(side=tk.LEFT, padx=5)
        self.entry.bind("", lambda e: self.proposer())
        self.btn = tk.Button(self.frame_saisie, text="Proposer",
                            command=self.proposer)
        self.btn.pack(side=tk.LEFT)

        # Infos
        self.label_info = tk.Label(racine, text=f"Erreurs : 0/{self.max_erreurs}",
                                   font=("Arial", 14))
        self.label_info.pack(pady=10)
        self.label_lettres = tk.Label(racine, text="Lettres essayées : ",
                                      font=("Arial", 12))
        self.label_lettres.pack(pady=5)

    def afficher_mot(self):
        return " ".join(l if l in self.lettres_trouvees else "_" for l in self.mot)

    def proposer(self):
        lettre = self.entry.get().lower().strip()
        self.entry.delete(0, tk.END)
        if not lettre or len(lettre) != 1 or not lettre.isalpha():
            return
        if lettre in self.lettres_trouvees:
            return

        self.lettres_trouvees.add(lettre)
        if lettre not in self.mot:
            self.erreurs += 1

        self.label_mot.config(text=self.afficher_mot())
        self.label_info.config(text=f"Erreurs : {self.erreurs}/{self.max_erreurs}")
        self.label_lettres.config(
            text=f"Lettres essayées : {', '.join(sorted(self.lettres_trouvees))}")

        if all(l in self.lettres_trouvees for l in self.mot):
            self.label_info.config(text="Bravo ! Vous avez gagné !",
                                   fg="green")
            self.btn.config(state=tk.DISABLED)
        elif self.erreurs >= self.max_erreurs:
            self.label_mot.config(text=self.mot)
            self.label_info.config(text=f"Perdu ! Le mot était : {self.mot}",
                                   fg="red")
            self.btn.config(state=tk.DISABLED)

racine = tk.Tk()
jeu = JeuPendu(racine)
racine.mainloop()

Ce que vous apprenez : programmation événementielle, widgets Tkinter, gestion d’état dans une classe, binding de touches clavier. Ce projet montre comment passer d’un programme en ligne de commande à une véritable application avec interface utilisateur.

Projet 10 : Mini application web avec Flask

Le projet le plus ambitieux de cette liste : une application web complète avec Flask. Vous créez un mini blog avec une page d’accueil, un formulaire d’ajout d’articles et un stockage en JSON. Installez Flask avec pip install flask.

from flask import Flask, render_template_string, request, redirect, url_for
import json
import os
from datetime import datetime

app = Flask(__name__)
FICHIER = "articles.json"

TEMPLATE = """
<!DOCTYPE html>
<html lang="fr">
<head><meta charset="utf-8"><title>Mini Blog Python</title>
<style>
  body { font-family: Arial, sans-serif; max-width: 700px; margin: 40px auto;
         padding: 0 20px; background: #f5f5f5; }
  .article { background: white; padding: 20px; margin: 15px 0;
             border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
  .article h2 { margin-top: 0; color: #2c3e50; }
  .article .date { color: #7f8c8d; font-size: 0.85em; }
  form input, form textarea { width: 100%%; padding: 10px;
                               margin: 8px 0; box-sizing: border-box; }
  form button { background: #3498db; color: white; padding: 12px 24px;
                border: none; border-radius: 4px; cursor: pointer; }
  nav a { margin-right: 15px; text-decoration: none; color: #3498db; }
</style>
</head>
<body>
  <nav><a href="/">Accueil</a> <a href="/nouveau">Nouvel article</a></nav>
  <h1>{{ titre }}</h1>
  {{ contenu }}
</body>
</html>
"""

def charger_articles():
    if os.path.exists(FICHIER):
        with open(FICHIER, "r", encoding="utf-8") as f:
            return json.load(f)
    return []

def sauvegarder_articles(articles):
    with open(FICHIER, "w", encoding="utf-8") as f:
        json.dump(articles, f, ensure_ascii=False, indent=2)

@app.route("/")
def accueil():
    articles = charger_articles()
    html_articles = ""
    for a in reversed(articles):
        html_articles += f"""
        <div class="article">
          <h2>{a['titre']}</h2>
          <p class="date">{a['date']}</p>
          <p>{a['contenu']}</p>
        </div>"""
    if not articles:
        html_articles = "<p>Aucun article pour le moment.</p>"
    return render_template_string(TEMPLATE, titre="Mini Blog Python",
                                  contenu=html_articles)

@app.route("/nouveau", methods=["GET", "POST"])
def nouveau():
    if request.method == "POST":
        articles = charger_articles()
        articles.append({
            "titre": request.form["titre"],
            "contenu": request.form["contenu"],
            "date": datetime.now().strftime("%d/%m/%Y à %H:%M")
        })
        sauvegarder_articles(articles)
        return redirect(url_for("accueil"))

    formulaire = """
    <form method="post">
      <input name="titre" placeholder="Titre de l'article" required>
      <textarea name="contenu" rows="6" placeholder="Contenu..." required></textarea>
      <button type="submit">Publier</button>
    </form>"""
    return render_template_string(TEMPLATE, titre="Nouvel article",
                                  contenu=formulaire)

if __name__ == "__main__":
    app.run(debug=True)

Ce que vous apprenez : framework web Flask, routes et méthodes HTTP, templates HTML, gestion de formulaires. Ce projet est une excellente porte d’entrée vers le développement web back-end et vous prépare à des frameworks plus complets comme Django. Pour héberger votre projet, pensez à créer un portfolio sur GitHub Pages qui présentera tous vos travaux.

Comment structurer vos projets sur GitHub

Coder un projet, c’est bien. Le documenter et le versionner sur GitHub, c’est ce qui fait la différence sur un CV. Voici la structure que je recommande à mes étudiants pour chaque projet :

mon-projet-python/
├── README.md          # Description, installation, utilisation
├── requirements.txt   # Dépendances (pip freeze > requirements.txt)
├── main.py           # Point d'entrée du programme
├── src/              # Code source (pour les projets plus complexes)
│   └── ...
└── tests/            # Tests unitaires
    └── test_main.py

Chaque dépôt doit avoir un README.md clair qui explique ce que fait le projet, comment l’installer et comment l’utiliser. Utilisez les commandes Git pour versionner votre travail dès le début : un commit par fonctionnalité ajoutée, avec des messages explicites.

Pensez aussi à créer un fichier .gitignore pour exclure les fichiers inutiles :

__pycache__/
*.pyc
.env
venv/
*.json  # si ce sont des données générées

Un recruteur qui visite votre profil GitHub regardera d’abord si vos projets sont bien documentés et structurés, avant même de lire le code. La qualité de la présentation compte autant que la qualité technique.

Erreurs courantes et bonnes pratiques

Après plusieurs années à corriger les projets de mes étudiants, voici les erreurs que je retrouve le plus souvent, et comment les éviter :

1. Ne pas gérer les erreurs utilisateur. Si votre programme attend un nombre et reçoit du texte, il plante. Utilisez systématiquement try/except pour les entrées utilisateur. C’est une habitude à prendre dès le premier projet.

2. Tout mettre dans un seul fichier. C’est acceptable pour les petits projets, mais dès que votre code dépasse 200 lignes, découpez-le en modules. Un fichier par responsabilité : modeles.py, utilitaires.py, interface.py.

3. Copier du code sans le comprendre. Je vois des étudiants coller des solutions trouvées en ligne sans comprendre chaque ligne. Prenez le temps de taper le code vous-même et d’expérimenter en modifiant des parties pour voir ce qui change.

4. Oublier l’encodage UTF-8. En français, vous aurez des accents dans vos données. Spécifiez toujours encoding="utf-8" quand vous ouvrez un fichier, sinon votre programme plantera sur certains systèmes.

5. Négliger les noms de variables. Un code lisible utilise des noms explicites : liste_contacts plutôt que lc, nombre_tentatives plutôt que n. Python encourage la lisibilité; profitez-en.

Pour approfondir vos compétences, je vous recommande d’utiliser les meilleurs outils pour étudiants en informatique et de consulter la documentation officielle Python en français.

Aller plus loin avec Python

Une fois ces 10 projets terminés, vous aurez acquis des bases solides. Voici les pistes que je conseille pour continuer votre progression :

Approfondissez la POO. Étudiez l’héritage, les classes abstraites et les design patterns. Transformez le carnet de contacts (projet 6) en une application multi-utilisateurs avec des classes spécialisées.

Découvrez les tests unitaires. Le module unittest est intégré à Python. Écrivez des tests pour chacun de vos projets : c’est la meilleure façon de vérifier que votre code fonctionne et qu’il continue de fonctionner quand vous le modifiez.

Explorez les bibliothèques populaires. pandas pour l’analyse de données, matplotlib pour la visualisation, django pour le développement web avancé. Python est un langage qui figure parmi les meilleurs langages de programmation en 2026 justement grâce à cet écosystème riche.

Contribuez à l’open source. Cherchez des projets Python sur GitHub avec le label « good first issue ». Contribuer à un projet existant vous apprendra la collaboration, les revues de code et les bonnes pratiques professionnelles.

Préparez des certifications. Si vous souhaitez valider formellement vos compétences, consultez notre guide sur les certifications informatiques gratuites en 2026. La certification PCEP (Python Certified Entry-Level Programmer) du Python Institute est un excellent premier objectif.

Enfin, restez en veille technologique : Python évolue régulièrement avec de nouvelles fonctionnalités (pattern matching en 3.10, groupes d’exceptions en 3.11, messages d’erreur améliorés en 3.12). Suivez les PEPs (Python Enhancement Proposals) pour comprendre dans quelle direction le langage se dirige.

Lucie Moreau

Formatrice IT indépendante depuis 2016, ancienne étudiante BTS SIO SLAM. 6 ans d'expérience en entreprise.