Python — Programmation orientée objet et récursivité

Affecter une variable ne copie pas l'objet : cela lui donne un second nom, et modifier l'un modifie ce que voit l'autre. Pour les objets immuables — entiers, chaînes, tuples — la question ne se pose pas, puisqu'on ne peut pas les modifier en place. Pour les objets modifiables — listes, dictionnaires — elle se pose à chaque affectation, à chaque passage en argument de fonction et à chaque valeur par défaut.

Classe et instance — Une classe est un modèle : elle décrit les attributs — les données — et les méthodes — les opérations — que partageront ses objets. Une instance est un objet construit à partir de ce modèle. Le constructeur initialise les attributs propres à chaque instance : deux objets d'une même classe partagent leurs méthodes et possèdent chacun ses valeurs d'attributs.

Encapsulation — L'encapsulation consiste à regrouper dans un même objet les données et les opérations qui les manipulent, et à n'exposer qu'une interface d'usage. Son intérêt n'est pas la dissimulation : c'est de garantir que l'objet reste dans un état cohérent. Si toute modification passe par une méthode, cette méthode peut vérifier ce qu'elle reçoit ; si l'attribut est modifié directement de l'extérieur, aucune vérification n'est possible.

Héritage — L'héritage permet à une classe de réutiliser les attributs et méthodes d'une autre, en les spécialisant. La classe dérivée peut ajouter des membres et redéfinir une méthode existante. La relation à vérifier est « est un » : un carré est un rectangle, donc l'héritage se discute. En revanche une voiture n'est pas un moteur — elle en possède un, et c'est une composition, non un héritage.

Une fonction récursive s'appelle elle-même. Elle exige deux éléments, et l'oubli du premier est l'erreur la plus fréquente : un cas de base, qui renvoie une valeur sans appel récursif, et un appel récursif qui se rapproche strictement de ce cas de base. Sans cette progression, les appels s'empilent jusqu'à saturer la pile d'appels.

Écrire la factorielle de façon récursive et vérifier sa terminaison.

1. Cas de base : la factorielle de 0 vaut 1, sans aucun appel récursif.
2. Appel récursif : la factorielle de n vaut n multiplié par la factorielle de n − 1.
3. La progression est stricte — n diminue de 1 à chaque appel — donc le cas de base est atteint. Pour n = 4 :$4\times 3\times 2\times 1=24$

factorielle(4) = 24

Une exception signale une situation qu'une fonction ne peut pas traiter elle-même : fichier absent, division par zéro, conversion impossible. Le bloc try/except permet de la rattraper et de décider quoi faire. Deux règles d'usage : rattraper le type d'exception précis que l'on sait traiter, et ne jamais rattraper toutes les exceptions pour n'en rien faire — un programme qui masque ses erreurs échoue silencieusement, ce qui est pire qu'un arrêt net.

Écrire une fonction récursive qui se termine

1. Écrire d'abord le cas de base : quelle est la plus petite entrée, et que renvoie-t-on alors ?
2. Formuler le cas général en fonction d'un cas plus petit, sans chercher à dérouler les appels.
3. Vérifier que chaque appel se rapproche strictement du cas de base.$4\times 3\times 2\times 1=24$n décroît de 1 à chaque appel et atteint 0.
4. Tester sur la plus petite entrée, puis sur la suivante : les deux premiers cas valident la structure.
5. Vérifier la profondeur atteinte, et le nombre d'appels répétés avant de conclure à l'efficacité.