L'essentiel en une minute
Ces 19 exercices Python débutant vont du calcul d'une durée à un petit gestionnaire de tâches qui enregistre ses données dans un fichier. Chaque exercice donne un énoncé court, un indice, une solution complète et la sortie que vous devez obtenir. Si Python n'est pas encore installé sur votre machine, commencez par notre guide Apprendre Python en 2026, qui couvre l'installation et un plan d'apprentissage : cette page ne les répète pas.
Toutes les solutions ont été exécutées le 30 octobre 2026 avec Python 3.10.11, 3.11.9 et 3.12.3 : chaque sortie affichée est celle de l'interpréteur, identique sur les trois versions. La dernière version publiée est Python 3.15.2, sortie le 25 octobre 2026 selon la page de téléchargement de python.org.
Points clés
- 18 exercices en 4 niveaux plus un projet final, l'exercice 19 : variables et conditions, boucles et chaînes, listes et dictionnaires, puis fonctions, exceptions et fichiers.
- Chaque exercice suit le même format : énoncé, indice, solution, sortie attendue et piège à retenir.
- Les solutions n'utilisent que la bibliothèque standard et supposent Python 3.7 ou plus récent.
- Un débutant est loin d'être seul : dans la Python Developers Survey 2024, 21 % des répondants programmaient en Python depuis moins d'un an.
- Pour progresser, cherchez au moins 15 minutes avant d'ouvrir la solution, puis modifiez-la au lieu de la recopier.
Comment utiliser ces exercices Python débutant
Lisez l'énoncé, essayez seul, puis l'indice si vous bloquez, et seulement ensuite la solution : une solution lue trop tôt donne l'impression d'avoir compris sans laisser de trace.
Écrivez chaque exercice dans un fichier, par exemple exercice01.py, et lancez-le avec python exercice01.py dans un terminal. Notre comparatif des IDE et éditeurs de code aide à choisir un éditeur, et notre sélection d'extensions VS Code complète l'installation.
Les sorties supposent Python 3.7 ou plus récent : la documentation indique que l'ordre d'insertion des dictionnaires est garanti depuis la version 3.7 (types natifs, documentation Python). Et les exercices 18 et 19 créent un fichier dans le dossier courant : lancez-les dans un dossier de travail.
Si votre programme produit la même sortie avec un autre code, il est probablement juste : comparez les deux versions. Testez-le aussi avec d'autres valeurs, comme 0, un nombre négatif ou une liste vide.
Le tableau de progression
Les exercices sont classés du plus simple au plus complet. Les temps sont indicatifs, estimés par l'auteur pour une première tentative, indice compris.
| N° | Exercice | Notion travaillée | Niveau | Temps indicatif |
|---|---|---|---|---|
| 1 | Convertir des secondes | Variables, // et %
|
1 | 10 min |
| 2 | Prix TTC | Types, conversion, f-string | 1 | 10 min |
| 3 | Signe et parité |
if, elif, else
|
1 | 10 min |
| 4 | Année bissextile | Conditions combinées | 1 | 15 min |
| 5 | Mention d'une note | Chaîne de elif
|
1 | 10 min |
| 6 | Table de multiplication | Boucle for, range
|
2 | 10 min |
| 7 | Chiffres d'un nombre | Boucle while
|
2 | 15 min |
| 8 | FizzBuzz | Boucle et modulo | 2 | 15 min |
| 9 | Compter les voyelles | Parcours de chaîne | 2 | 15 min |
| 10 | Palindrome | Tranches, accents | 2 | 20 min |
| 11 | Statistiques de notes | Listes, sum, compréhension |
3 | 15 min |
| 12 | Supprimer les doublons | Listes et ensembles | 3 | 15 min |
| 13 | Fréquence des mots | Dictionnaire, tri | 3 | 25 min |
| 14 | Moyennes d'une classe | Dictionnaire de listes | 3 | 20 min |
| 15 | Nombre premier | Fonction, return, assert
|
4 | 20 min |
| 16 | Convertir des températures | Paramètre par défaut | 4 | 15 min |
| 17 | Saisies invalides |
try, except
|
4 | 20 min |
| 18 | Carnet de dépenses | Fichier CSV | 4 | 30 min |
| 19 | Gestionnaire de tâches | Projet : fonctions, JSON | Projet | 60 min |
Niveau 1 : variables, types et conditions
Ce premier niveau ne demande que des variables, des opérations et des conditions. La partie du tutoriel officiel sur Python comme calculatrice explique les opérateurs // et %, et la page sur l'instruction if couvre les conditions.
Exercice 1 : convertir des secondes
Énoncé. Une variable contient une durée de 7 384 secondes. Affichez-la en heures, minutes et secondes.
Indice. La division entière // donne le nombre d'heures ; le reste % donne ce qui reste à convertir.
total = 7384
heures = total // 3600
minutes = (total % 3600) // 60
secondes = total % 60
print(f"{total} secondes = {heures} h {minutes} min {secondes} s")
Sortie attendue :
7384 secondes = 2 h 3 min 4 s
À retenir. // et % vont toujours ensemble : l'un donne le quotient, l'autre le reste.
Exercice 2 : calculer un prix TTC
Énoncé. Un prix hors taxe arrive sous forme de texte, "19.90", comme le renverrait input(). Calculez le total TTC de 3 articles avec une TVA de 20 % et affichez les types utilisés.
Indice. input() renvoie toujours une chaîne : convertissez-la avec float() avant de calculer.
prix_saisi = "19.90" # ce que renverrait input()
quantite = 3
taux_tva = 0.20
prix_ht = float(prix_saisi)
total_ttc = prix_ht * quantite * (1 + taux_tva)
print(type(prix_saisi), type(prix_ht), type(quantite))
print(f"Total TTC : {total_ttc:.2f} euros")
Sortie attendue :
<class 'str'> <class 'float'> <class 'int'>
Total TTC : 71.64 euros
À retenir. Le format :.2f arrondit l'affichage à deux décimales ; il ne modifie pas la valeur stockée.
Exercice 3 : signe et parité
Énoncé. Pour n = -7, affichez si le nombre est positif, négatif ou nul, et s'il est pair ou impair.
Indice. Un nombre est pair si le reste de sa division par 2 vaut 0. Testez aussi le cas n = 0.
n = -7
if n > 0:
signe = "positif"
elif n < 0:
signe = "négatif"
else:
signe = "nul"
parite = "pair" if n % 2 == 0 else "impair"
print(f"{n} est {signe} et {parite}")
Sortie attendue :
-7 est négatif et impair
À retenir. En Python, -7 % 2 vaut 1 : le test de parité marche aussi pour les nombres négatifs.
Exercice 4 : année bissextile
Énoncé. Indiquez si 1900, 2000, 2026 et 2028 sont bissextiles. Une année l'est si elle est divisible par 4 sans l'être par 100, ou si elle est divisible par 400.
Indice. Traduisez la règle mot pour mot avec and, or et des parenthèses.
for annee in (1900, 2000, 2026, 2028):
if (annee % 4 == 0 and annee % 100 != 0) or annee % 400 == 0:
print(annee, "est bissextile")
else:
print(annee, "n'est pas bissextile")
Sortie attendue :
1900 n'est pas bissextile
2000 est bissextile
2026 n'est pas bissextile
2028 est bissextile
À retenir. 1900 et 2000 sont les deux pièges classiques. Vérifiez votre réponse avec calendar.isleap() du module standard calendar.
Exercice 5 : mention d'une note
Énoncé. Pour une note sur 20, affichez « Très bien » à partir de 16, « Bien » à partir de 14, « Assez bien » à partir de 12, « Admis » à partir de 10, sinon « Non admis ». Refusez une note hors de l'intervalle 0 à 20.
Indice. Testez d'abord la validité, puis les seuils du plus haut au plus bas.
note = 14.5
if not 0 <= note <= 20:
print("Note invalide")
elif note >= 16:
print("Très bien")
elif note >= 14:
print("Bien")
elif note >= 12:
print("Assez bien")
elif note >= 10:
print("Admis")
else:
print("Non admis")
Sortie attendue :
Bien
À retenir. Dans une suite de elif, seule la première branche vraie s'exécute.
Niveau 2 : boucles et chaînes de caractères
Ce niveau répète des instructions et parcourt du texte. La documentation sur l'instruction for et celle des méthodes de chaînes sont les deux références utiles.
Exercice 6 : table de multiplication
Énoncé. Affichez la table de 7, de 1 à 10, avec des colonnes alignées.
Indice. range(1, 11) s'arrête avant 11. Dans une f-string, {i:2} réserve deux caractères.
nombre = 7
for i in range(1, 11):
print(f"{nombre} x {i:2} = {nombre * i:3}")
Sortie attendue :
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63
7 x 10 = 70
À retenir. La borne de fin de range est exclue : c'est l'erreur de décalage la plus fréquente.
Exercice 7 : compter les chiffres d'un nombre
Énoncé. Sans convertir en texte, comptez les chiffres de 2026 et calculez leur somme.
Indice. n % 10 donne le dernier chiffre, n // 10 le retire. Répétez tant que n est positif.
n = 2026
nb_chiffres = 0
somme = 0
while n > 0:
somme += n % 10 # dernier chiffre
n //= 10 # on le retire
nb_chiffres += 1
print(f"{nb_chiffres} chiffres, somme = {somme}")
Sortie attendue :
4 chiffres, somme = 10
À retenir. Une boucle while doit modifier sa condition à chaque tour, sinon elle ne s'arrête jamais. Ce code affiche 0 chiffre pour n = 0 et pour un nombre négatif : à vous de traiter ces cas (indice : la fonction abs()).
Exercice 8 : FizzBuzz
Énoncé. Affichez les nombres de 1 à 15, mais « Fizz » pour les multiples de 3, « Buzz » pour les multiples de 5 et « FizzBuzz » pour les multiples des deux.
Indice. L'ordre des tests compte : vérifiez d'abord le cas le plus restrictif.
for i in range(1, 16):
if i % 15 == 0:
print("FizzBuzz")
elif i % 3 == 0:
print("Fizz")
elif i % 5 == 0:
print("Buzz")
else:
print(i)
Sortie attendue :
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
À retenir. Si vous testez i % 3 en premier, 15 affiche « Fizz » : la branche FizzBuzz n'est jamais atteinte.
Exercice 9 : compter les voyelles
Énoncé. Comptez les voyelles de la phrase « Python est un langage élégant et très lisible », lettres accentuées comprises, en considérant le y comme une voyelle.
Indice. Mettez la phrase en minuscules avec lower(), puis testez chaque lettre avec l'opérateur in.
phrase = "Python est un langage élégant et très lisible"
voyelles = "aeiouyàâéèêëîïôùûü"
compte = 0
for lettre in phrase.lower():
if lettre in voyelles:
compte += 1
print(f"{compte} voyelles")
Sortie attendue :
15 voyelles
À retenir. Sans les lettres accentuées, « élégant » et « très » perdent trois voyelles, un cas que beaucoup de corrigés oublient.
Exercice 10 : palindrome avec accents
Énoncé. Vérifiez si une phrase se lit dans les deux sens en ignorant les espaces, la casse et les accents. Testez « Ésope reste ici et se repose » et « Python ».
Indice. texte[::-1] inverse une chaîne. Pour retirer les accents, le module unicodedata sépare la lettre de son accent avec la forme NFD.
import unicodedata
for phrase in ("Ésope reste ici et se repose", "Python"):
decompose = unicodedata.normalize("NFD", phrase.lower())
propre = "".join(c for c in decompose if c.isalnum())
print(phrase, "->", propre == propre[::-1])
Sortie attendue :
Ésope reste ici et se repose -> True
Python -> False
À retenir. Après NFD, « é » devient « e » suivi d'un accent séparé, que isalnum() écarte avec les espaces.
Niveau 3 : listes et dictionnaires
Les structures de données font passer d'un calcul isolé à un traitement de séries. Le chapitre du tutoriel sur les structures de données couvre listes, ensembles et dictionnaires.
Exercice 11 : statistiques de notes
Énoncé. À partir de la liste [12, 8.5, 15, 17, 9, 13.5], affichez la note minimale, la maximale, la moyenne et les notes supérieures à la moyenne. Prévoyez le cas d'une liste vide.
Indice. min(), max(), sum() et len() font l'essentiel. Une liste en compréhension filtre en une ligne.
notes = [12, 8.5, 15, 17, 9, 13.5]
if notes:
moyenne = sum(notes) / len(notes)
au_dessus = [n for n in notes if n > moyenne]
print(f"Min : {min(notes)}, max : {max(notes)}")
print(f"Moyenne : {moyenne:.2f}")
print("Au-dessus de la moyenne :", au_dessus)
else:
print("Aucune note")
Sortie attendue :
Min : 8.5, max : 17
Moyenne : 12.50
Au-dessus de la moyenne : [15, 17, 13.5]
À retenir. Une liste vide est évaluée comme fausse : le test if notes: évite une division par zéro.
Exercice 12 : supprimer les doublons
Énoncé. Retirez les doublons de ["lea", "omar", "lea", "ines", "omar", "jules"] en gardant l'ordre de première apparition.
Indice. set() retire les doublons mais ne garde pas l'ordre. Utilisez un ensemble pour mémoriser ce que vous avez déjà vu.
inscrits = ["lea", "omar", "lea", "ines", "omar", "jules"]
deja_vus = set()
uniques = []
for nom in inscrits:
if nom not in deja_vus:
deja_vus.add(nom)
uniques.append(nom)
print(uniques)
print(list(dict.fromkeys(inscrits))) # variante en une ligne
Sortie attendue :
['lea', 'omar', 'ines', 'jules']
['lea', 'omar', 'ines', 'jules']
À retenir. La variante dict.fromkeys() repose sur l'ordre d'insertion des dictionnaires, garanti depuis Python 3.7.
Exercice 13 : fréquence des mots
Énoncé. Dans un court texte, comptez chaque mot sans tenir compte de la ponctuation, puis affichez les trois mots les plus fréquents.
Indice. compteur.get(mot, 0) renvoie 0 si le mot est absent. Pour trier par nombre d'occurrences, passez une fonction à key : lambda paire: paire[1] est une petite fonction sans nom qui renvoie le second élément de chaque paire (mot, nombre).
texte = """le chat dort. le chien dort aussi.
le chat mange, puis le chat dort."""
compteur = {}
for mot in texte.lower().split():
mot = mot.strip(".,;:!?")
compteur[mot] = compteur.get(mot, 0) + 1
classement = sorted(compteur.items(), key=lambda paire: paire[1], reverse=True)
for mot, nombre in classement[:3]:
print(mot, nombre)
Sortie attendue :
le 4
chat 3
dort 3
À retenir. « chat » et « dort » sont à égalité : le guide officiel du tri précise que les tris sont stables, donc l'ordre d'origine est conservé.
Exercice 14 : moyennes d'une classe
Énoncé. Un dictionnaire associe chaque élève à ses notes. Calculez la moyenne de chacun et affichez le classement, du meilleur au moins bon.
Indice. items() donne les paires élève et notes. Un dictionnaire en compréhension construit les moyennes en une ligne, et le tri reprend la lambda de l'exercice 13.
carnet = {
"Léa": [14, 16, 12],
"Omar": [9, 11, 13],
"Inès": [18, 15, 17],
}
moyennes = {eleve: sum(notes) / len(notes) for eleve, notes in carnet.items()}
for eleve, moyenne in sorted(moyennes.items(), key=lambda p: p[1], reverse=True):
print(f"{eleve:<5} {moyenne:5.2f}")
Sortie attendue :
Inès 16.67
Léa 14.00
Omar 11.00
À retenir. :<5 aligne le nom à gauche sur cinq caractères, :5.2f aligne la moyenne à droite avec deux décimales.
Niveau 4 : fonctions, exceptions et fichiers
Ce niveau introduit ce qui structure un vrai programme : des fonctions réutilisables, la gestion des exceptions et la lecture et l'écriture de fichiers.
Exercice 15 : tester si un nombre est premier
Énoncé. Écrivez une fonction est_premier(n) qui renvoie True ou False, vérifiez-la avec assert, puis affichez les nombres premiers inférieurs à 30.
Indice. Il suffit de tester les diviseurs tant que leur carré ne dépasse pas n.
def est_premier(n):
"""Renvoie True si n est un nombre premier."""
if n < 2:
return False
diviseur = 2
while diviseur * diviseur <= n:
if n % diviseur == 0:
return False
diviseur += 1
return True
assert est_premier(2) and est_premier(29)
assert not est_premier(1) and not est_premier(21)
print([n for n in range(30) if est_premier(n)])
Sortie attendue :
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
À retenir. Une fonction qui renvoie sa valeur avec return se teste et se réutilise ; une fonction qui affiche, non.
Exercice 16 : convertir des températures
Énoncé. Écrivez convertir(valeur, vers="F") qui convertit des degrés Celsius en Fahrenheit par défaut, et l'inverse avec vers="C". Une unité inconnue doit lever une erreur.
Indice. La formule est F = C x 9 / 5 + 32. raise ValueError(...) signale une valeur incorrecte.
def convertir(valeur, vers="F"):
"""Convertit une température entre degrés Celsius et Fahrenheit."""
if vers == "F":
return valeur * 9 / 5 + 32
if vers == "C":
return (valeur - 32) * 5 / 9
raise ValueError(f"Unité inconnue : {vers}")
print(convertir(100))
print(convertir(-40, "F"))
print(round(convertir(98.6, vers="C"), 1))
try:
convertir(20, "K")
except ValueError as erreur:
print("Erreur :", erreur)
Sortie attendue :
212.0
-40.0
37.0
Erreur : Unité inconnue : K
À retenir. Un paramètre par défaut rend l'appel le plus courant plus court ; l'appel nommé vers="C" le rend lisible.
Exercice 17 : ignorer les saisies invalides
Énoncé. Écrivez moyenne_saisies(saisies) qui convertit une liste de textes en entiers, signale ceux qui ne sont pas des entiers et renvoie la moyenne, ou None si rien n'est valide.
Indice. int("7.5") lève une ValueError, comme int("abc"). Une division par une liste vide lève ZeroDivisionError.
def moyenne_saisies(saisies):
valides = []
for saisie in saisies:
try:
valides.append(int(saisie))
except ValueError:
print(f"Ignoré : {saisie!r}")
try:
return sum(valides) / len(valides)
except ZeroDivisionError:
return None
print(moyenne_saisies(["12", "abc", "7.5", "-3", "15"]))
print(moyenne_saisies(["x"]))
Sortie attendue :
Ignoré : 'abc'
Ignoré : '7.5'
8.0
Ignoré : 'x'
None
À retenir. L'exercice 11 testait avant d'agir (if notes:) ; ici, on essaie puis on attrape l'erreur, pratique quand le test serait plus compliqué que la conversion. N'attrapez que l'exception attendue : un except: sans nom masque aussi vos fautes de frappe.
Exercice 18 : carnet de dépenses en CSV
Énoncé. Écrivez cinq dépenses dans depenses.csv, relisez le fichier et affichez le total par catégorie. Une ligne au montant illisible doit être ignorée sans arrêter le programme.
Indice. Le module csv lit et écrit ce format ; sa documentation demande d'ouvrir le fichier avec newline=''. csv.DictReader donne chaque ligne sous forme de dictionnaire.
import csv
lignes = [
("2026-10-01", "courses", "54.20"),
("2026-10-03", "transport", "17.50"),
("2026-10-08", "courses", "32.80"),
("2026-10-12", "loisirs", "abc"),
("2026-10-15", "transport", "17.50"),
]
with open("depenses.csv", "w", newline="", encoding="utf-8") as fichier:
ecrivain = csv.writer(fichier)
ecrivain.writerow(["date", "categorie", "montant"])
ecrivain.writerows(lignes)
totaux = {}
with open("depenses.csv", newline="", encoding="utf-8") as fichier:
for ligne in csv.DictReader(fichier):
try:
montant = float(ligne["montant"])
except ValueError:
print("Ligne ignorée :", ligne["date"])
continue
categorie = ligne["categorie"]
totaux[categorie] = totaux.get(categorie, 0) + montant
for categorie, total in totaux.items():
print(f"{categorie:<10} {total:7.2f}")
Sortie attendue :
Ligne ignorée : 2026-10-12
courses 87.00
transport 35.00
À retenir. Le bloc with ferme le fichier même en cas d'erreur. Précisez toujours encoding="utf-8" pour que les accents passent d'un système à l'autre. Pour de vrais montants, sachez que float arrondit en binaire (0.1 + 0.2 affiche 0.30000000000000004, comme l'explique le tutoriel sur les nombres à virgule flottante) : le module decimal calcule en base 10.
Projet final : un gestionnaire de tâches
Le dernier exercice réunit tout ce qui précède dans un programme utile : une liste de tâches qui survit à la fermeture du programme grâce à un fichier JSON.
Exercice 19 : gestionnaire de tâches en console
Énoncé. Écrivez les fonctions charger, sauvegarder, ajouter, terminer et afficher. Ajoutez trois tâches, marquez la deuxième comme faite, provoquez une erreur sur une tâche inexistante, sauvegardez, puis rechargez et affichez.
Indice. Le module json transforme une liste de dictionnaires en texte et inversement. Si le fichier n'existe pas encore, FileNotFoundError vous le dit : renvoyez alors une liste vide.
import json
from pathlib import Path
FICHIER = Path("taches.json")
def charger():
"""Lit les tâches depuis le fichier, ou renvoie une liste vide."""
try:
return json.loads(FICHIER.read_text(encoding="utf-8"))
except FileNotFoundError:
return []
def sauvegarder(taches):
FICHIER.write_text(json.dumps(taches, ensure_ascii=False, indent=2), encoding="utf-8")
def ajouter(taches, titre):
taches.append({"titre": titre, "faite": False})
def terminer(taches, numero):
if not 1 <= numero <= len(taches):
raise IndexError(f"Pas de tâche n° {numero}")
taches[numero - 1]["faite"] = True
def afficher(taches):
for i, tache in enumerate(taches, start=1):
case = "x" if tache["faite"] else " "
print(f"{i}. [{case}] {tache['titre']}")
taches = charger()
ajouter(taches, "Relire le chapitre sur les dictionnaires")
ajouter(taches, "Faire l'exercice 13")
ajouter(taches, "Pousser le projet sur GitHub")
terminer(taches, 2)
try:
terminer(taches, 9)
except IndexError as erreur:
print("Erreur :", erreur)
sauvegarder(taches)
afficher(charger())
Sortie attendue au premier lancement :
Erreur : Pas de tâche n° 9
1. [ ] Relire le chapitre sur les dictionnaires
2. [x] Faire l'exercice 13
3. [ ] Pousser le projet sur GitHub
À retenir. Au second lancement, les tâches s'ajoutent à celles déjà enregistrées : la sauvegarde fonctionne. Pour aller plus loin, ajoutez un menu avec input(), une fonction supprimer, et attrapez json.JSONDecodeError dans charger() au cas où le fichier serait corrompu.
Le module pathlib gère les chemins de fichiers. Publiez ce projet sur GitHub avec un court README : notre guide pour construire un portfolio de développeur explique comment le présenter.
Exercices Python en seconde : lesquels choisir
Les élèves de seconde peuvent faire les exercices 1 à 8, 15 et 16. Le document ressource « Algorithmique et programmation » d'Eduscol, publié en 2019 par le ministère de l'Éducation nationale, l'écrit sans détour : « Le langage de programmation choisi au lycée (voies générale et technologique) est le langage Python » (Eduscol, consulté le 30 octobre 2026).
Le même document présente la fonction informatique comme une nouveauté de seconde et introduit la liste en première. Il précise qu'« aucune technicité au niveau de la syntaxe du langage Python n'est attendue » : la compréhension passe avant l'optimisation.
Ce document de 2019 accompagnait l'ancien programme. Un arrêté du 26 février 2026 remplace le programme de mathématiques de seconde à partir de la rentrée 2026-2027 (Légifrance, consulté le 30 octobre 2026). Nous n'avons pas pu lire son annexe : la répartition des notions ci-dessous suit le document de 2019 et peut avoir changé.
D'où cette sélection :
- Exercices 1 à 8 : variables, conditions et boucles.
-
Exercices 15 et 16 : des fonctions dont les entrées « apparaissent comme paramètres », selon les mots du document, plutôt que d'être lues avec
input(). -
Exercices 11 et 12 : pour la première, où arrivent les listes. Les exercices 13 et 14, avec dictionnaires et
lambda, relèvent plutôt de la spécialité NSI.
Eduscol accompagne ce document de treize activités pour la seconde et la première, comme le nombre de chiffres d'un nombre, proche de notre exercice 7.
Comment s'entraîner efficacement
Avec des exercices Python débutant, la régularité compte plus que la quantité : un exercice par jour vaut mieux qu'une série recopiée le dimanche.
- Chercher avant de lire. Donnez-vous 15 minutes, puis l'indice, puis encore 10 minutes avant la solution.
- Casser la solution. Une fois l'exercice réussi, changez une valeur, supprimez une ligne et prédisez le résultat avant de lancer.
- Lire l'erreur en entier. La dernière ligne donne le type d'exception, les précédentes l'endroit.
- Refaire sans regarder. Reprenez un exercice trois jours plus tard, sans la solution.
Vous ne serez pas le seul à débuter. La Python Developers Survey 2024, menée par la Python Software Foundation et JetBrains en octobre et novembre 2024, a réuni plus de 30 000 participants et retenu plus de 25 000 réponses après filtrage. Sur sa page de résultats, 21 % des répondants programment en Python depuis moins d'un an et 18 % depuis un à deux ans (Python Developers Survey 2024, consulté le 30 octobre 2026).
La même enquête montre où ces développeurs se forment aux nouveaux outils : la documentation arrive en tête, à 58 % en 2024 contre 55 % en 2023, et les outils d'IA passent de 19 % à 27 %.
Prenez donc l'habitude d'ouvrir la documentation officielle, traduite en français, dès qu'une fonction vous est inconnue. Avec une IA, demandez un indice ou l'explication d'une erreur, pas la solution : notre article sur l'usage de l'IA pour coder résume ce qu'en disent les études.
Une fois ces exercices maîtrisés, un projet personnel prend le relais. Plus tard, quand les bibliothèques externes vous seront familières, notre guide sur le RAG propose un exemple pratique en Python d'un niveau nettement plus avancé.
Ce que nous n'avons pas pu vérifier
Les points suivants restent ouverts :
- Python 3.15. Les solutions ont été exécutées avec Python 3.10.11, 3.11.9 et 3.12.3, pas avec Python 3.15.2. Elles n'utilisent aucune fonction propre à une version récente.
- Le programme de seconde 2026. Nous avons lu l'arrêté du 26 février 2026 sur Légifrance, mais pas son annexe, qui détaille la partie algorithmique et programmation.
- Les temps indicatifs. Ce sont des estimations de l'auteur, pas des mesures.
- La portée de l'enquête. La Python Developers Survey interroge des personnes qui utilisent déjà Python. Ses chiffres de 2024 sont les plus récents que nous ayons trouvés.
Questions fréquentes
Existe-t-il une version PDF de ces exercices Python débutant ?
Pas pour l'instant. Imprimez la page depuis votre navigateur, ou mieux, copiez chaque solution dans un fichier .py : un exercice se fait en exécutant du code.
Combien de temps faut-il pour faire les 19 exercices ?
Le total de nos estimations est d'environ six heures, projet compris. Étalez ces exercices Python débutant sur deux à trois semaines, à raison d'un ou deux exercices par jour, et refaites ceux qui vous ont posé problème.
Faut-il connaître les maths pour faire ces exercices ?
Non. Seuls le modulo, la divisibilité, la moyenne et une formule de conversion apparaissent, et l'indice donne la formule quand il en faut une.
Que faire après ces exercices ?
Construisez un projet personnel, même petit, et publiez-le. Notre guide Apprendre Python en 2026 propose un plan sur 12 semaines et des idées de projets, et le tutoriel officiel aborde ensuite les classes, la notion suivante après les fonctions.
À propos de l'auteur
Abdelilah Ourti est ingénieur IA et architecte logiciel. Il conçoit et déploie des applications web et des systèmes d'IA, et publie sur NeurauTech des guides et des comparatifs destinés aux développeurs francophones. Ses autres articles sont réunis sur sa page auteur.
Méthode. Les exercices ont été écrits pour cet article. Chaque solution a été exécutée avec Python 3.10.11, 3.11.9 et 3.12.3, et sa sortie copiée telle quelle. Les références techniques viennent de la documentation officielle de Python en français ; le cadre scolaire, du document ressource d'Eduscol et de l'arrêté de 2026 publié sur Légifrance ; les chiffres, de la Python Developers Survey 2024 de la Python Software Foundation et JetBrains. Aucun lien n'est affilié et aucune relation commerciale ne lie l'auteur aux organismes mentionnés.
Une erreur dans une solution ? Écrivez à contact@neurautech.com : l'article sera corrigé et la date de mise à jour modifiée.
Dernière mise à jour : 30 octobre 2026.
Image : Vitaly Gariev (Unsplash License). Graphiques : NeurauTech, d'après la Python Developers Survey 2024.
Top comments (0)