Langages et programmation en Terminale
Cours complet, points clés à retenir et exercices d'entraînement de langages et programmation pour les élèves de Terminale. Conforme au programme officiel.
Réviser notion par notion
Ce que tu vas réviser
- Notion de programme en tant que donnée
- Calculabilité, décidabilité
- Récursivité
- Modularité
- Paradigmes de programmation
- Mise au point des programmes, gestion des bugs
Programme en tant que donnée
Un programme est une suite d'instructions qu'on peut stocker, transformer et exécuter. Comme n'importe quelle donnée (texte, image), un programme peut être manipulé par un autre programme.
Exemple
Quand tu télécharges une application sur ton téléphone, tu télécharges un fichier qui est lui-même une donnée. Un autre logiciel (l'OS) peut lire ce fichier et l'exécuter.
À retenir : Un programme écrit en langage de programmation est une donnée textuelle que l'ordinateur peut interpréter et exécuter.
Calculabilité et décidabilité
La calculabilité demande si on peut écrire un programme pour résoudre un problème. La décidabilité demande si on peut écrire un programme qui répond par oui ou non à une question en temps fini.
Exemple
Calculer la somme de deux nombres ? Calculable. Savoir si un nombre est pair ? Décidable. Prédire si un programme s'arrêtera un jour (Problème de l'arrêt) ? Non décidable — aucun algorithme ne peut le garantir.
À retenir : Certains problèmes mathématiques ne peuvent pas être résolus par un algorithme, quelle que soit sa puissance.
Récursivité
Une fonction qui s'appelle elle-même avec des paramètres différents, jusqu'à atteindre un cas de base qui arrête la récursion.
Exemple
Calculer la factorielle : pour trouver 5!, tu calcules 5 × 4!, et pour 4! tu calcules 4 × 3!, etc., jusqu'à 1! = 1. La fonction s'appelle elle-même.
À retenir : Toute fonction récursive doit avoir un cas de base (condition d'arrêt) sinon elle s'appelle infiniment.
Modularité et décomposition
Découper un gros programme en plusieurs petites fonctions indépendantes, chacune responsable d'une tâche simple. Chaque fonction peut être testée seule.
Exemple
Pour faire un jeu vidéo : une fonction pour dessiner, une pour gérer les événements clavier, une pour calculer les collisions. Tu peux tester chaque fonction sans avoir le jeu complet.
À retenir : Un programme modulaire est plus facile à comprendre, tester et corriger qu'un gros bloc monolithique.
Paradigmes de programmation
Différentes façons de concevoir un programme : impératif (suite d'ordres), orienté objet (objets qui communiquent), fonctionnel (fonctions pures), déclaratif (on décrit le résultat voulu).
Exemple
Impératif : « fais ceci, puis cela ». Orienté objet : « crée une Voiture avec vitesse et accélération ». Fonctionnel : « applique la fonction carré à chaque nombre de cette liste ».
À retenir : Le paradigme qu'on choisit influence comment on écrit le code et sa lisibilité.
Mise au point et débogage
Trouver et corriger les erreurs (bugs) dans un programme. On utilise des techniques comme l'exécution étape par étape, les points d'arrêt ou l'affichage de valeurs intermédiaires.
Exemple
Tu écris une fonction pour calculer la moyenne de notes. Elle retourne 0. Tu ajoutes des print() pour voir les valeurs à chaque étape et tu découvres que la variable somme n'est jamais mise à jour dans la boucle (on a écrit somme + note au lieu de somme = somme + note) : elle vaut toujours 0.
À retenir : Un bug vient souvent d'une hypothèse implicite ; bien comprendre le code aide plus que cliquer partout.
Gestion des bugs et exceptions
Anticiper les erreurs possibles et les gérer : utiliser try/except pour attraper les erreurs, valider les entrées de l'utilisateur, tester les cas limites.
Exemple
Un utilisateur entre du texte au lieu d'un nombre. Au lieu de crasher, le programme affiche « Erreur : veuillez entrer un nombre ». On utilise try/except pour capturer l'erreur.
À retenir : Prévoir et gérer les erreurs rend un programme robuste et fiable en production.
Les points clés
- Un programme est une donnée manipulable par d'autres programmes
- Certains problèmes (comme l'arrêt d'un programme) ne sont pas décidables algorithmiquement
- La récursion nécessite impérativement un cas de base pour terminer
- La modularité améliore la compréhension, la testabilité et la maintenance
- Les paradigmes (impératif, objet, fonctionnel) offrent différentes perspectives pour résoudre un problème
- Le débogage consiste à localiser la cause, pas juste le symptôme
- Les exceptions permettent de gérer les erreurs prévisibles sans interrompre le programme
L'essentiel
Écrire du bon code c'est : le rendre modulaire pour qu'il soit compréhensible, l'anticiper pour éviter les bugs, et le tester en pensant aux cas limites.
Exercices d'entraînement
Entraîne-toi sur ces exercices, puis fais-toi corriger pas à pas par le tuteur.
Exercice 1
Écris une fonction récursive qui calcule la somme des entiers de 1 à n. Puis modifie-la pour afficher combien de fois elle s'appelle elle-même.
Corrige cet exercice avec le tuteur →Exercice 2
Un programme demande l'âge de l'utilisateur et doit afficher « Adulte » ou « Mineur ». Écris le code sans try/except d'abord, puis avec gestion d'erreur.
Corrige cet exercice avec le tuteur →