Exercices Python progressifs pour vraiment progresser

On progresse rarement en Python en lisant uniquement des explications. Le déclic arrive quand on doit transformer une consigne en variables, conditions, boucles puis tests. Je propose ici une série d’exercices Python progressifs, avec des exemples corrigés, une méthode de travail et les erreurs qui bloquent le plus souvent les débutants.

Commencer par des exercices qui font vraiment progresser

La demande autour de l’exercice Python est surtout pratique et pédagogique. Les lecteurs veulent des énoncés accessibles, des corrections compréhensibles et une difficulté qui augmente sans saut brutal. Une liste de problèmes trop complexes dès le départ décourage vite, tandis qu’une série composée uniquement de calculs simples ne prépare pas aux vrais programmes.

Je recommande donc de suivre une progression en quatre étapes. On apprend d’abord à manipuler les données, puis à prendre des décisions, à répéter une action et enfin à organiser son code. Le tableau suivant donne un repère réaliste.

Le temps importe moins que la capacité à expliquer son raisonnement. Un programme court que l’on comprend vaut mieux qu’une correction copiée sans savoir pourquoi elle fonctionne.

Trois exercices pour poser les bases

Calculer une moyenne

Demandez trois notes à l’utilisateur, calculez la moyenne et affichez une appréciation selon le résultat. Cet exercice travaille input(), la conversion avec float() et les conditions.

note1 = float(input("Première note : "))
note2 = float(input("Deuxième note : "))
note3 = float(input("Troisième note : "))

moyenne = (note1 + note2 + note3) / 3
print(f"Moyenne : {moyenne:.2f}")

if moyenne >= 10:
    print("Résultat : admis")
else:
    print("Résultat : à revoir")

Le piège classique consiste à oublier que input() renvoie toujours du texte. Sans conversion, Python ne peut pas additionner correctement des nombres saisis au clavier.

Identifier un nombre pair

Écrivez un programme qui indique si un entier est pair ou impair. La notion importante est l’opérateur modulo, représenté par %, qui renvoie le reste d’une division.

nombre = int(input("Entrez un entier : "))

if nombre % 2 == 0:
    print("Ce nombre est pair.")
else:
    print("Ce nombre est impair.")

J’aime cet exercice parce qu’il oblige à traduire une règle mathématique en condition logique. Pour aller plus loin, testez 0, -4 et vérifiez plusieurs valeurs successives afin de ne pas limiter votre raisonnement aux exemples évidents.

Compter de 1 à 100

Affichez les nombres de 1 à 100, mais remplacez les multiples de 3 par « Python ». Vous pouvez ensuite remplacer les multiples de 5 par « Code » et ceux de 3 et 5 par « Python Code ».

for nombre in range(1, 101):
    if nombre % 15 == 0:
        print("Python Code")
    elif nombre % 3 == 0:
        print("Python")
    elif nombre % 5 == 0:
        print("Code")
    else:
        print(nombre)

L’ordre des conditions est essentiel. Le test sur 15 doit arriver avant celui sur 3 et celui sur 5, sinon le programme s’arrête trop tôt. C’est un bon exemple de détail qui paraît mineur mais qui révèle la logique réelle d’un algorithme.

Des défis pour passer des notions aux petits programmes

Analyser une liste de nombres

À partir d’une liste, calculez la somme, la moyenne, la plus grande valeur et le nombre d’éléments positifs. Une première version peut utiliser les fonctions intégrées, puis une seconde peut refaire les calculs avec une boucle.

valeurs = [12, -3, 7, 0, 18, 4]

somme = sum(valeurs)
moyenne = somme / len(valeurs)
maximum = max(valeurs)
positifs = sum(1 for valeur in valeurs if valeur > 0)

print("Somme :", somme)
print("Moyenne :", moyenne)
print("Maximum :", maximum)
print("Positifs :", positifs)

La version avec sum(), len() et max() est concise, mais la version avec une boucle aide à comprendre ce que fait réellement Python. Je conseille de connaître les deux approches, car la lisibilité et la rapidité d’écriture ne répondent pas toujours au même besoin.

Créer un jeu de devinettes

Le programme choisit un nombre secret et donne à l’utilisateur un nombre limité d’essais. Il faut gérer la boucle, les comparaisons et l’arrêt lorsque la bonne réponse est trouvée.

nombre_secret = 42
essais_max = 5

for numero_essai in range(1, essais_max + 1):
    proposition = int(input("Votre proposition : "))

    if proposition == nombre_secret:
        print(f"Bravo en {numero_essai} essai(s) !")
        break
    elif proposition < nombre_secret:
        print("Le nombre est plus grand.")
    else:
        print("Le nombre est plus petit.")
else:
    print("Vous avez utilisé tous vos essais.")

Le bloc else placé après la boucle for s’exécute seulement si la boucle se termine sans rencontrer break. Cette construction est souvent méconnue, mais elle devient très utile pour les recherches limitées et les systèmes de tentatives.

Lire aussi : Python global - Éviter les pièges des variables globales

Construire un compteur de mots

Demandez une phrase, séparez-la en mots et comptez les occurrences de chacun. Ce défi introduit les dictionnaires, une structure indispensable dès que l’on analyse des textes ou des données.

phrase = input("Écrivez une phrase : ").lower()
mots = phrase.split()
compteur = {}

for mot in mots:
    compteur[mot] = compteur.get(mot, 0) + 1

for mot, nombre in compteur.items():
    print(f"{mot} : {nombre}")

La méthode get() évite une erreur lorsque le mot n’existe pas encore dans le dictionnaire. Dans un projet réel, il faudrait aussi retirer la ponctuation et traiter les accents, mais cette première version permet de comprendre le mécanisme sans alourdir le problème.

Une méthode simple pour résoudre chaque énoncé

Avant d’écrire du code, je reformule toujours la consigne en une suite d’actions. Cette étape prend rarement plus de deux minutes et évite de se perdre dans la syntaxe.

1. Repérer les données d’entrée et leur type attendu.
2. Décrire le résultat que le programme doit produire.
3. Découper le problème en petites opérations.
4. Écrire une première solution simple, même si elle comporte des répétitions.
5. Tester trois cas dont un cas limite ou inhabituel.
6. Améliorer le code seulement après avoir obtenu un résultat correct.

Un cas limite peut être une liste vide, une note égale à 10, un nombre négatif ou une phrase composée d’un seul mot. C’est souvent là que les erreurs apparaissent. Les plateformes pédagogiques comme CodEx sont intéressantes lorsqu’elles proposent des tests visibles et cachés, car elles vérifient davantage que le seul exemple fourni dans l’énoncé.

Je conseille aussi de ne pas ouvrir la correction immédiatement. Accordez-vous 20 minutes de recherche autonome, puis consultez uniquement un indice. La correction complète doit servir à comparer les choix et à comprendre une autre approche, pas à remplacer l’effort de réflexion.

Les erreurs qui ralentissent le plus les débutants

La syntaxe n’est pas toujours le vrai problème. Dans la pratique, les blocages viennent souvent d’une mauvaise lecture de l’énoncé ou de tests trop limités.

• Confondre = et == : le premier affecte une valeur, le second compare deux valeurs.
• Oublier l’indentation : en Python, les espaces définissent les blocs de code.
• Modifier une liste pendant son parcours : cela peut faire sauter des éléments ou produire un résultat inattendu.
• Utiliser une variable avant de l’avoir créée : vérifiez toujours son ordre d’initialisation.
• Tester uniquement le cas idéal : ajoutez des valeurs nulles, négatives, vides ou très grandes.
• Copier une correction sans la réécrire : on reconnaît alors le code, mais on ne sait pas le reconstruire seul.

Une autre erreur fréquente consiste à vouloir optimiser trop tôt. Pour apprendre, une solution lisible avec une boucle est souvent plus formatrice qu’une expression compacte. Une fois le résultat validé, vous pourrez comparer les performances et réduire le code si cela apporte réellement quelque chose.

Transformer quelques exercices en vraie progression

Pour avancer sans vous disperser, choisissez trois problèmes par semaine. Faites un exercice de révision, un exercice légèrement plus difficile et un mini-projet qui réutilise les notions apprises, comme un convertisseur, un gestionnaire de tâches ou un analyseur de dépenses.

Gardez vos solutions dans des fichiers séparés et ajoutez une courte note sur ce que vous avez appris. Après un mois, vous disposerez d’une dizaine de programmes relisibles, ce qui est bien plus utile qu’une longue liste d’exercices commencés puis abandonnés.

Le meilleur exercice Python n’est donc pas forcément le plus spectaculaire. C’est celui qui vous oblige à réfléchir un peu, que vous pouvez tester correctement et qui vous donne envie d’ajouter une fonctionnalité. Cette régularité construit des réflexes durables, bien plus sûrement qu’une session intensive suivie de plusieurs semaines sans pratique.