NSI · terminale spe

Chapitre 4 — Langages et programmation

L'essentiel en 30 secondes

La récursivité, c'est une fonction qui s'appelle elle-même avec un cas de base qui stoppe les appels. La POO (Programmation Orientée Objet) structure le code en classes (attributs + méthodes) et objets (instances). La modularité consiste à découper un programme en modules/fonctions testables indépendamment. Ces trois outils rendent le code lisible, maintenable et réutilisable.

Notions clés

Récursivité: Fonction qui s'appelle elle-même. Nécessite un cas de base (arrêt) et un cas récursif qui se rapproche du cas de base.
Pile d'appels (call stack): Chaque appel récursif empile un contexte. Si trop d'appels : RecursionError. Limite Python par défaut : 1000.
Classe: Modèle (plan) qui définit des attributs (données) et des méthodes (comportements). Ex : class Voiture.
Objet (instance): Variable créée à partir d'une classe. Ex : ma_voiture = Voiture('rouge', 2024). Chaque objet a ses propres attributs.
Encapsulation: Principe de regrouper données et traitements dans un objet, en contrôlant l'accès (convention _ pour privé en Python).
Modularité: Découpage du code en fonctions et modules (fichiers .py) indépendants, chacun avec une responsabilité claire.

Formules

Factorielle récursive

`def factorielle(n):\n if n == 0: # cas de base\n return 1\n return n * factorielle(n - 1) # cas récursif`

Condition : Complexité O(n) en temps et en espace (pile d'appels)

Classe avec __init__ et méthode

`class Compteur:\n def __init__(self):\n self.valeur = 0\n def incrementer(self):\n self.valeur += 1\n def __str__(self):\n return f'Compteur({self.valeur})'`

Condition : __init__ = constructeur, self = référence à l'objet courant

Import de module

`import math\nfrom utils import ma_fonction\nimport random as rd`

Condition : 3 syntaxes d'import — évite `from module import *` (pollution du namespace)

A retenir

Toute fonction récursive doit avoir un cas de base explicite, sinon boucle infinie.
self est le premier paramètre de TOUTE méthode d'instance en Python — ne jamais l'oublier.
En POO, on accède aux attributs via self.attribut dans les méthodes et objet.attribut depuis l'extérieur.

Erreurs classiques

Erreur : Oublier le return dans la récursion

Correction : Écrire `return n * factorielle(n-1)` et pas juste `factorielle(n-1)`. Sans return, le résultat est perdu.

Erreur : Oublier self dans la définition d'une méthode

Correction : Toute méthode d'instance prend self en premier paramètre : `def ma_methode(self, ...):`.

Erreur : Modifier un attribut de classe au lieu d'un attribut d'instance

Correction : Définis les attributs dans __init__ avec self.attribut = ..., pas au niveau de la classe.

Astuce méthode

Pour toute fonction récursive au bac, dessine l'arbre des appels sur ton brouillon : note chaque appel, sa valeur de retour, et vérifie que les appels convergent bien vers le cas de base.