Algorithmique Python : exercice pas‑à‑pas pour débutants en classe de terminale

Beaucoup d’élèves de terminale veulent apprendre Python sans se noyer dans la théorie. Le bon réflexe, c’est de partir d’exercices simples, de comprendre la logique derrière chaque ligne, puis d’augmenter la difficulté par petites marches. C’est exactement ce qui permet de passer d’un code copié à un vrai raisonnement algorithmique.

Avant de commencer : le minimum utile

En terminale, l’objectif n’est pas de tout savoir sur Python. Il faut surtout maîtriser quelques briques solides :

• les variables pour stocker une information ;
• les conditions pour décider ;
• les boucles pour répéter ;
• les fonctions pour organiser ;
• les listes pour manipuler plusieurs valeurs.

Si ces bases sont claires, la plupart des exercices de lycée deviennent accessibles. Le piège, en revanche, consiste à apprendre des bouts de code sans comprendre quand les utiliser. Un bon exercice sert justement à faire le lien entre le problème posé et la structure Python adaptée.

Installer un environnement simple, sans se compliquer la vie

Pour débuter, inutile de partir sur un système trop lourd. L’idée est de pouvoir tester rapidement, corriger, recommencer.

Les options les plus pratiques

• Thonny : très lisible, idéal pour comprendre ce qui se passe ligne par ligne.
• IDLE : fourni avec Python, simple et suffisant pour commencer.
• Un éditeur comme VS Code : intéressant plus tard, quand on veut aller plus loin.

Le plus important : choisir un outil qui affiche clairement les erreurs. Quand on débute, voir où le programme casse est déjà un apprentissage en soi.

Trois habitudes à prendre dès le départ

1. Nommer clairement ses variables : moyenne, age, temperature plutôt que x ou a.
2. Tester souvent : après chaque petite modification, exécuter le programme.
3. Lire les messages d’erreur : ils ne sont pas là pour décourager, mais pour guider.

La méthode la plus efficace : découper le problème

Un exercice d’algorithmique paraît souvent flou au départ. La bonne approche consiste à le fragmenter.

Exemple de démarche

Supposons qu’on vous demande : « Écrire un programme qui indique si un nombre est pair ou impair. »

Avant de coder, posez-vous ces questions :

• Quelle est l’information d’entrée ? → un nombre.
• Quel test faut-il faire ? → vérifier le reste de la division par 2.
• Que doit afficher le programme ? → “pair” ou “impair”.

Cette logique est essentielle. Elle évite de lancer Python à l’aveugle.

Le schéma mental à retenir

• Entrée : ce que le programme reçoit.
• Traitement : ce qu’il calcule ou vérifie.
• Sortie : ce qu’il affiche ou renvoie.

Ce trio simple sert pour une grande partie des exercices de terminale.

Exercice 1 : pair ou impair, version pas à pas

Voici un premier exercice classique, très utile pour comprendre la condition.

Énoncé

Demander un nombre entier à l’utilisateur et afficher s’il est pair ou impair.

Étapes de résolution

1. Récupérer le nombre avec input().
2. Le convertir en entier avec int().
3. Vérifier si le reste de la division par 2 vaut 0.
4. Afficher le bon message.

Code commenté

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

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

Ce qu’il faut comprendre

• input() lit une saisie en texte.
• int() transforme ce texte en entier.
• % calcule le reste d’une division.
• if ... else choisit entre deux chemins.

Cet exercice semble simple, mais il concentre déjà une grosse partie des réflexes de base.

Exercice 2 : somme des entiers de 1 à n

Là, on passe à la boucle. C’est souvent à ce moment que les élèves bloquent, parce qu’ils voient la boucle comme un objet abstrait. En réalité, une boucle sert juste à répéter une action sans réécrire dix fois la même chose.

Énoncé

Demander un entier n puis calculer la somme de tous les entiers de 1 à n.

Méthode

On peut procéder de deux façons :

• en additionnant un par un dans une boucle ;
• en utilisant une formule, si elle est connue.

Pour apprendre Python, la première méthode est la plus intéressante.

Code

n = int(input("Entrez un entier positif : "))
somme = 0

for i in range(1, n + 1):
    somme = somme + i

print("La somme vaut :", somme)

Décryptage

• somme = 0 : on initialise le résultat.
• range(1, n + 1) : on parcourt les nombres de 1 à n inclus.
• somme = somme + i : on ajoute progressivement chaque valeur.

Erreur fréquente

Beaucoup oublient le + 1. En Python, range(1, n + 1) est nécessaire pour inclure n. Sans cela, la boucle s’arrête juste avant.

Exercice 3 : compter combien de fois une valeur apparaît dans une liste

Les listes sont omniprésentes : notes d’élèves, mesures de laboratoire, données récoltées lors d’un projet.

Énoncé

Écrire un programme qui compte le nombre d’occurrences d’une valeur dans une liste.

Exemple simple

Liste : [2, 4, 2, 7, 2, 9] Valeur recherchée : 2 Résultat : 3

Code

liste = [2, 4, 2, 7, 2, 9]
valeur = 2
compteur = 0

for element in liste:
    if element == valeur:
        compteur = compteur + 1

print("Nombre d'occurrences :", compteur)

Pourquoi cet exercice est utile

Il entraîne à :

• parcourir une liste ;
• comparer une valeur ;
• utiliser un compteur.

Ce sont des mécanismes fondamentaux. On les retrouve dans des versions plus avancées : moyenne, recherche d’un maximum, filtrage de valeurs, classement.

Exercice 4 : trouver le maximum d’une liste

L’idée est similaire, mais avec un changement important : on ne compte plus, on compare.

Code

notes = [12, 15, 9, 18, 14]
maximum = notes[0]

for note in notes:
    if note > maximum:
        maximum = note

print("La plus grande valeur est :", maximum)

Point clé

On commence avec le premier élément de la liste. C’est une méthode simple et robuste. Elle évite d’inventer une valeur arbitraire qui pourrait fausser le résultat.

À retenir

Pour chercher un maximum ou un minimum :

• on prend une valeur de départ crédible ;
• on compare chaque élément ;
• on met à jour si nécessaire.

Comment progresser sans se décourager

L’erreur classique, c’est de vouloir faire des exercices trop ambitieux trop vite. Il vaut mieux réussir cinq exercices simples que rater un gros problème mal découpé.

Une progression efficace

1. Lire l’énoncé lentement et repérer les mots-clés.
2. Écrire en français les étapes du raisonnement.
3. Coder une version minimale qui fonctionne.
4. Tester avec plusieurs exemples.
5. Améliorer seulement après.

Cette méthode fait gagner du temps, car elle réduit les erreurs de départ.

Astuce très utile : écrire le programme en pseudo-code

Avant de coder, rédigez quelque chose comme :

• demander un nombre ;
• vérifier s’il est positif ;
• afficher un message adapté.

Ce n’est pas du Python, mais cela clarifie l’idée. En terminale, cette étape peut faire une vraie différence sur les exercices plus longs.

Les erreurs les plus fréquentes des débutants

1. Confondre texte et nombre

input() renvoie du texte. Si vous voulez faire un calcul, il faut souvent convertir avec int() ou float().

2. Oublier l’indentation

En Python, l’indentation n’est pas décorative. Elle structure le code. Une mauvaise indentation peut casser tout le programme.

3. Mal utiliser les boucles

Deux erreurs reviennent souvent :

• oublier qu’une boucle répète un bloc ;
• modifier une variable au mauvais endroit.

4. Tester avec un seul exemple

Un programme peut marcher pour un cas et échouer pour un autre. Testez toujours plusieurs entrées.

5. Copier sans comprendre

C’est le faux bon plan par excellence. Un code copié peut fonctionner une fois, mais il ne construit pas la compétence.

Une mini-méthode pour corriger ses bugs

Quand un programme ne marche pas, ne touchez pas tout d’un coup.

Procédure simple

1. Lire le message d’erreur jusqu’au bout.
2. Repérer la ligne indiquée.
3. Vérifier les parenthèses, guillemets et indentations.
4. Afficher des valeurs intermédiaires avec print() si besoin.
5. Simplifier le problème : tester une version réduite.

Cette approche est beaucoup plus efficace que de modifier le code au hasard.

Vers des exercices plus utiles pour la terminale

Une fois les bases maîtrisées, on peut aller vers des exercices plus proches des situations scolaires :

• calcul de moyenne avec gestion de plusieurs notes ;
• conversion d’unités ;
• simulation simple d’un phénomène ;
• traitement de listes de mesures ;
• recherche d’un seuil ou d’une condition.

Ces exercices sont intéressants parce qu’ils relient la programmation à d’autres matières. Python devient alors un outil, pas seulement un objet d’étude.

En résumé

Pour progresser en algorithmique Python en terminale, il faut viser la clarté avant la sophistication. Les bons réflexes sont simples : comprendre l’énoncé, découper le problème, coder petit, tester souvent, corriger méthodiquement.

Les bases à maîtriser en priorité sont les variables, les conditions, les boucles et les listes. Avec quelques exercices bien choisis — pair/impair, somme, comptage, maximum — on construit déjà une vraie autonomie. Et c’est cette autonomie qui fait la différence, en classe comme pour la suite des études.