Comment gérer les erreurs en Python ?

On utilise les blocs try et except. Le code susceptible de provoquer une erreur est placé dans le bloc try, et si une exception est levée, elle est attrapée par le bloc except correspondant. On peut aussi utiliser finally pour exécuter du code dans tous les cas.

Pourquoi confond-on récursivité et gestion des erreurs ?

Parce que les deux notions impliquent le mot 'erreur' : une récursivité mal écrite provoque une erreur (comme RecursionError), et la gestion des erreurs permet de traiter ces erreurs. Mais ce sont des concepts distincts : la récursivité est une technique de programmation, tandis que la gestion des erreurs est un mécanisme de robustesse.

Quels sont les pièges classiques en récursivité au bac NSI ?

Les pièges courants sont : oublier le cas de base, faire un appel récursif qui ne diminue pas la taille du problème, ou utiliser une récursivité trop profonde qui dépasse la limite de la pile. Il faut aussi savoir simuler l'exécution étape par étape.

Quelle est la différence entre lever une exception et l'attraper ?

Lever une exception (avec raise) signifie qu'on crée une erreur volontairement pour signaler un problème. Attraper une exception (avec try/except) signifie qu'on intercepte une erreur qui s'est produite pour la gérer, par exemple en affichant un message à l'utilisateur.

Récursivité vs Gestion des erreurs : ne plus confondre en NSI

Q: Qu'est-ce que la récursivité en programmation ?

La récursivité est une technique où une fonction s'appelle elle-même dans sa propre définition. Elle est utilisée pour résoudre des problèmes qui peuvent être décomposés en sous-problèmes identiques plus petits. En Python, on doit définir un cas de base pour arrêter les appels, sinon on obtient une récursion infinie.

Tu as peut-être déjà entendu parler de récursivité et de gestion des erreurs en cours de NSI, et tu les confonds ? Pas de panique ! Dans cet article, on va clarifier ces deux notions essentielles du programme de Première et Terminale. Tu vas comprendre pourquoi une fonction récursive est parfois magique, et comment gérer les erreurs avec les exceptions pour rendre ton code plus robuste. On va voir des exemples concrets en Python, et à la fin, tu sauras les distinguer sans hésiter.

La récursivité : une fonction qui s'appelle elle-même

Commençons par la récursivité. En programmation, une fonction est dite récursive si, dans sa définition, elle fait appel à elle-même. C'est une technique puissante pour résoudre des problèmes qui peuvent être décomposés en sous-problèmes plus petits, de même nature. Par exemple, le calcul de la factorielle d'un nombre entier positif n (noté n!) peut se définir simplement :

0! = 1 (cas de base)
n! = n × (n-1)! pour n > 0 (appel récursif)

En Python, cela donne :

def factorielle(n):
    if n == 0:
        return 1
    else:
        return n * factorielle(n-1)

Ici, factorielle(5) va appeler factorielle(4), qui appelle factorielle(3), etc., jusqu'à atteindre le cas de base n == 0. C'est ce qu'on appelle la récursivité. Il est crucial de définir un cas de base (ou condition d'arrêt) pour éviter une boucle infinie qui provoquerait une erreur de récursion (en Python, RecursionError).

Comment visualiser le déroulement ?

Pour bien comprendre, imagine une pile d'assiettes. Chaque appel récursif empile une nouvelle assiette. Quand le cas de base est atteint, on dépile les assiettes en revenant en arrière. En Python, chaque appel utilise de la mémoire dans la pile d'exécution. C'est pourquoi une récursion trop profonde peut dépasser la limite et provoquer une erreur. Mais ne t'inquiète pas, pour les exercices de NSI, la profondeur est souvent raisonnable.

La gestion des erreurs et exceptions : protéger son programme

La gestion des erreurs (ou des exceptions) est un autre mécanisme essentiel. En Python, quand une erreur se produit pendant l'exécution (comme une division par zéro, une conversion de type impossible, un fichier introuvable), le programme lève une exception. Si on ne la traite pas, le programme s'arrête brutalement avec un message d'erreur. Pour éviter cela, on utilise les blocs try et except.

try:
    nombre = int(input("Donne un entier : "))
    resultat = 10 / nombre
    print("Résultat :", resultat)
except ZeroDivisionError:
    print("Tu ne peux pas diviser par zéro !")
except ValueError:
    print("Ce n'est pas un entier valide.")

Ici, si l'utilisateur entre une lettre, une ValueError sera attrapée ; s'il entre 0, ce sera ZeroDivisionError. Le programme ne plante pas et affiche un message d'aide. C'est ça, la gestion des erreurs : anticiper les problèmes et réagir proprement.

Pourquoi on les confond souvent ?

La confusion vient peut-être du fait que les deux notions utilisent le mot "erreur" dans des contextes différents. La récursivité peut générer une erreur si elle est mal écrite (comme une récursion infinie), et la gestion des erreurs permet justement de capturer ces erreurs. Mais ce sont deux concepts distincts : l'un est une technique de programmation, l'autre est un mécanisme de robustesse.

En NSI, au bac, tu peux avoir des exercices où l'on te demande d'écrire une fonction récursive, et d'autres où l'on te demande de gérer des exceptions. Il est donc important de savoir les identifier et les utiliser séparément.

Exemple concret : combiner les deux intelligemment

Prenons un exemple qui combine les deux : une fonction qui calcule la somme des entiers de 1 à n de manière récursive, mais qui vérifie que n est bien un entier positif.

def somme_entiers(n):
    if not isinstance(n, int) or n < 0:
        raise ValueError("n doit être un entier positif")
    if n == 0:
        return 0
    else:
        return n + somme_entiers(n-1)

try:
    print(somme_entiers(5))
    print(somme_entiers(-3))
except ValueError as e:
    print("Erreur :", e)

Ici, on utilise raise pour lever une exception si l'argument est invalide, et on l'attrape avec try/except. C'est une bonne pratique : une fonction récursive peut être protégée par une gestion d'erreurs.

Cas d'usage et mise en pratique

La récursivité est très utile pour parcourir des structures de données comme les arbres (par exemple, un arbre généalogique, un système de fichiers). La gestion des erreurs est indispensable dès que ton programme interagit avec l'utilisateur ou avec des ressources externes (fichiers, réseau).

Pour t'entraîner, tu peux essayer d'écrire une fonction récursive qui calcule le n-ième terme de la suite de Fibonacci, ou une fonction qui inverse une chaîne de caractères de manière récursive. Ensuite, ajoute une gestion d'erreurs pour les entrées négatives ou non entières.

Conseils pour le bac NSI

Lors de l'épreuve de NSI, tu peux avoir des questions sur la récursivité (par exemple, simuler l'exécution d'une fonction récursive, ou écrire une fonction récursive simple). Pour la gestion des erreurs, on peut te demander de proposer un try/except pour un code donné. Voici quelques conseils :

Pour la récursivité : identifie toujours le cas de base et l'appel récursif. Vérifie que la taille du problème diminue à chaque appel.
Pour les exceptions : connais les types d'erreurs courantes (ZeroDivisionError, ValueError, TypeError, FileNotFoundError) et utilise des blocs try/except pour les attraper.
Ne confonds pas raise (pour lever une erreur) et except (pour l'attraper).
Entraîne-toi avec les annales et les exercices en ligne, comme ceux proposés sur la page exercices de nsi-lycee.fr.

Aller plus loin

Si tu veux approfondir, tu peux consulter nos cours sur nsi-lycee.fr/cours qui détaillent ces notions avec des exemples supplémentaires. Pour la gestion des erreurs en Python, tu as un article dédié : les erreurs en Python.

N'oublie pas que la pratique est essentielle. N'hésite pas à faire des exercices, et si tu as besoin de soutien, tu peux jeter un œil à AlloBac ou AlloLycée pour des ressources complémentaires.

Conclusion

En résumé, la récursivité est une méthode de programmation où une fonction s'appelle elle-même, tandis que la gestion des erreurs est un mécanisme de protection du programme. Elles sont complémentaires et toutes deux au programme de NSI. Avec ces explications et un peu d'entraînement, tu ne les confondras plus. Continue comme ça, et surtout, amuse-toi en codant !