Programmation · Prog 11 · Les imprévus

Exceptions

Ce qui se passe quand un programme tombe sur un imprévu, et comment le prévoir.

Déjà à l'aise ? Aller directement au quiz

Dans la vraie vie

Mardi, 10 h 15, cours de maths. L’alarme incendie se met à sonner.

Exercice 3 x + 7 = 12 x = 12 − jamais écrit alarme sortie tout le monde sort

Le prof s’arrête au milieu de sa phrase : la suite du cours n’aura pas lieu, tout le monde sort.

Un programme aussi tombe parfois sur un imprévu.

Une note tapée « 5,5 » au lieu de 5.5, un fichier introuvable, un indice trop grand : il lève alors une exception et s’arrête net, comme le cours.

Et comme pour l’alarme, tout dépend de ce qui a été prévu : un plan d’évacuation, ou la panique.

En programmation, ce plan s’écrit dans le code.

Prévoir l’imprévu.

Au programme

  • 01lire une trace d’erreur
  • 02try, except, else, finally
  • 03le premier except qui correspond
  • 04l’exception qui remonte la pile
  • 05lever tes propres exceptions
  • 06fermer une ressource à coup sûr
  • 07les bons réflexes
Question pour toi : main appelle une fonction, qui en appelle une autre, qui plante. Qui doit réagir ?

Celle qui plante ?

Pas forcément. Réponse au chapitre 4, avec une histoire de boulangerie.

Une erreur, et tout s’arrête

Que se passe-t-il, exactement ?

Quand une instruction ne peut pas s’exécuter, Python crée un objet qui décrit le problème : une exception1.

int("douze") la ligne qui échoue ValueError invalid literal for int() with base 10: 'douze' un objet : un type, un message

Si personne ne la rattrape, le programme abandonne tout et affiche une trace.

Regarde ce programme recevoir « douze » au lieu d’un nombre.

age.py s’arrête net

Cinq lignes et une valeur inattendue : regarde ce que devient la suite.

age.pyprêt
  1. print("Début")
  2. texte = "douze"
  3. age = int(texte)
  4. print("Dans 10 ans :", age + 10)
  5. print("Fin")

Cinq lignes, que Python va exécuter une par une, de haut en bas.

Mon réflexe devant une trace : lire la dernière ligne d’abord.

Pas la première ?

La dernière dit quoi : le type et le message. La ligne « File » juste au-dessus dit où.

Chaque langage a ses noms d’exceptions, mais les situations se ressemblent.

JavaScript, lui, préfère souvent renvoyer une valeur spéciale plutôt que de lever une erreur.

Mêmes pannes, noms différents

Texte qui n’est pas un nombre

Python
ValueError
Java
NumberFormatException
JavaScript
aucune : NaN

Indice trop grand

Python
IndexError
Java
IndexOutOfBoundsException
JavaScript
aucune : undefined

Clé absente

Python
KeyError
Java
aucune : get renvoie null
JavaScript
aucune : undefined

Division par zéro

Python
ZeroDivisionError
Java
ArithmeticException, entiers seulement
JavaScript
aucune : Infinity

Utiliser « rien » comme un objet

Python
AttributeError sur None
Java
NullPointerException
JavaScript
TypeError

Fichier introuvable

Python
FileNotFoundError
Java
FileNotFoundException
JavaScript
Node : erreur ENOENT

Piège JavaScript

L’erreur qui passe en silence : parseFloat("5,5") donne 5. Il s’arrête à la virgule, sans rien signaler.

"5,5" parseFloat 5 ,5 « ,5 » ignoré, aucune alerte

Pareil : Number("douze") donne NaN, 10 / 0 donne Infinity. Teste la valeur (Number.isNaN) ou lève toi-même une erreur.

Exercice 1

Quelle exception ?

Chaque extrait est exécuté seul, en Python. Que lève-t-il ?

notes = [4.5, 5, 6]
print(notes[3])
notes = {"Léa": 5.5}
print(notes["Tom"])
eleve = None
print(eleve.nom)

Tendre un filet

Dans la vraie vie

Au cirque, le trapéziste s’élance au-dessus d’un filet.

le filet rattrapé : le spectacle continue

S’il rate, le filet le rattrape et le spectacle continue. Sans filet, une chute arrêterait tout.

try / except

Le saut risqué va dans try. Le filet, c’est except : à la première exception, le reste du try est abandonné et Python saute au except qui lui correspond1.

try: age = int(texte) print("Âge :", age) ValueError abandonnée except ValueError: print("Pas un nombre")

En Java et en JavaScript, except s’écrit catch.

Où l’image s’arrête : le trapéziste ne remonte pas finir son saut.

Après le except, le programme reprend après tout le bloc, jamais à la ligne qui a échoué.

else et finally

Deux blocs facultatifs : else, exécuté seulement si aucune exception n’a été levée, et finally, exécuté dans tous les cas1.

try exception aucune exception except else finally dans tous les cas

finally sert à ranger, quoi qu’il arrive.

Deux passages dans le même try

D’abord avec « 12 », puis avec « douze » : regarde quels blocs s’exécutent.

Deux passagestexte = "12"
  1. try:
  2. age = int(texte)
  3. print("Âge :", age)
  4. except ValueError:
  5. print("Pas un nombre")
  6. else:
  7. print("Lecture réussie")
  8. finally:
  9. print("Fin de la vérification")
  10. print("Suite du programme")

Premier passage : texte vaut « 12 ». Python entre dans le bloc try et exécute int(texte).

try

Le code qui risque d’échouer. À la première exception, la suite du bloc est abandonnée.

except

Rattrape l’exception de son type, et de ses descendants. En Java et en JavaScript : catch ; JavaScript n’en a qu’un, qui reçoit toutes les erreurs5.

else

Seulement si le try s’est terminé sans exception. Java et JavaScript n’en ont pas : la suite du cas réussi va à la fin du try.

finally

Dans tous les cas, même quand la fonction quitte le bloc par un return.

Dans une fonction, en quatre langages

lire_age en Python, Java, JavaScript et Go. Regarde la sortie : finally s’exécute même après un return.

Pythonage.py
def lire_age(texte):
    try:
        age = int(texte)
    except ValueError:
        print("Pas un nombre :", texte)
        return None
    else:
        return age
    finally:
        print("Vérification terminée")

print(lire_age("12"))
print(lire_age("douze"))
JavaAge.java
static Integer lireAge(String texte) {
    try {
        int age = Integer.parseInt(texte);
        return age;          // pas de else en Java
    } catch (NumberFormatException e) {
        System.out.println("Pas un nombre : " + texte);
        return null;
    } finally {
        System.out.println("Vérification terminée");
    }
}
// dans main :
System.out.println(lireAge("12"));
System.out.println(lireAge("douze"));
JavaScriptage.js
function lireAge(texte) {
    try {
        const age = Number(texte);
        if (Number.isNaN(age)) {
            throw new Error("Pas un nombre : " + texte);
        }
        return age;
    } catch (e) {
        console.log(e.message);
        return null;
    } finally {
        console.log("Vérification terminée");
    }
}
console.log(lireAge("12"));
console.log(lireAge("douze"));
Goage.go
func lireAge(texte string) (int, error) {
    age, err := strconv.Atoi(texte)
    if err != nil {
        return 0, fmt.Errorf("pas un nombre : %q", texte)
    }
    return age, nil
}

func main() {
    age, err := lireAge("douze")
    if err != nil {
        // affiche : pas un nombre : "douze"
        fmt.Println(err)
        return
    }
    fmt.Println(age)
}
Sortie de la version Python
Vérification terminée
12
Pas un nombre : douze
Vérification terminée
None

Les versions Java et JavaScript affichent la même chose, avec null à la place de None.

Et en Go ?

Go n’utilise pas d’exceptions pour les erreurs courantes : la fonction renvoie une valeur error, que l’appelant teste avec if err != nil6.

lireAge("douze") deux valeurs rendues age = 0 err != nil if err != nil { return }

panic et recover sont réservés aux situations graves.

Piège : un return dans finally

Il remplace la valeur renvoyée par le try, et fait même disparaître une exception en cours.

try: return 1 1 finally: return 2 2 g() renvoie 2

Python 3.14 affiche désormais un avertissement :

SyntaxWarning: 'return' in a 'finally' block

Garde finally pour ranger, pas pour renvoyer.

Exercice 2

Prédis la sortie

Qu'affiche chaque programme ?

try:
    x = int("7")
except ValueError:
    print("A")
else:
    print("B")
finally:
    print("C")
try:
    x = int("sept")
except ValueError:
    print("A")
else:
    print("B")
finally:
    print("C")
def f():
    try:
        return "try"
    finally:
        print("finally")

print(f())

Le premier qui correspond gagne

Dans la vraie vie

Un trieur de courrier a trois bacs, dans cet ordre : Lausanne, Vaud, Suisse.

bac Lausannebac Vaudbac Suisse Lausanne Yverdon Genève

Chaque lettre tombe dans le premier bac qui lui convient : Yverdon n’est pas Lausanne, mais c’est bien Vaud.

Des familles d’exceptions

Les exceptions sont des classes, rangées en familles comme à la fiche 8 : KeyError et IndexError sont deux sortes de LookupError, et presque toutes descendent d’Exception2.

Exception LookupError KeyError IndexError ValueError except LookupError : toute cette boîte

Un except rattrape son type et tous ses descendants, comme le bac Vaud prend les lettres pour Lausanne.

Python essaie les except dans l’ordre.

Il s’arrête au premier qui correspond1. Donc on les écrit du plus précis au plus général, comme les bacs.

Trois except, trois exceptions

Une division par zéro, une clé absente, puis un texte illisible : chacune teste les except de haut en bas.

Trois blocs exceptla famille

Trois except, du plus précis au plus général. En haut, la famille des exceptions concernées.

Plusieurs types d’un coup

Un tuple en Python, une barre verticale en Java, un test instanceof dans l’unique catch de JavaScript.

Pythonplusieurs types
notes = {"Léa": 5.5}
try:
    print(notes["Tom"] / 2)
except (KeyError, ZeroDivisionError) as e:
    print("Calcul impossible :", repr(e))
# Calcul impossible : KeyError('Tom')
Javaplusieurs types
try {
    int n = Integer.parseInt(texte);
    System.out.println(100 / n);
} catch (NumberFormatException | ArithmeticException e) {
    System.out.println("Calcul impossible : " + e);
}
// avec texte = "0", affiche :
// Calcul impossible :
// java.lang.ArithmeticException: / by zero
JavaScriptun seul catch
try {
    JSON.parse(texte);
} catch (e) {
    if (e instanceof SyntaxError) {
        console.log("JSON mal formé");
    } else {
        throw e;   // pas pour moi : on relance
    }
}

Piège : le plus général en premier

Mets le bac Suisse en tête, et tout le courrier y tombe. En Python, un except Exception placé en premier rattrape tout : les blocs suivants ne servent plus, sans le moindre message.

bac Suissebac Vaudbac Lausanne jamais utilisé jamais utilisé

Java, lui, refuse de compiler :

error: exception ArithmeticException has already been caught

Et un except tout seul ?

except: sans type rattrape tout, même Ctrl+C (KeyboardInterrupt) et sys.exit() (SystemExit). Ces deux-là descendent de BaseException, pas d’Exception2.

BaseException Exception KeyboardInterrupt SystemExit ValueError, KeyError… Ctrl+C sys.exit() except Exception except: tout seul

Nomme toujours le type que tu attends.

Alors, qui va réagir ?

Dans la vraie vie

Tu commandes un gâteau. La boulangère envoie son apprenti chercher des œufs : le frigo est vide.

toila boulangèrel’apprenti vide un gâteau ? des œufs ? pas d’œufs pas de gâteau plan B : une tarte

L’apprenti revient vers la boulangère, qui abandonne le gâteau et revient vers toi. Toi, tu as un plan B.

La pile d’appels

Chaque appel en cours occupe un cadre sur la pile d’appels (fiche 5). Une exception ? Python cherche un try dans la fonction en cours ; sinon, il la quitte, retire son cadre et recommence chez l’appelant1.

convertir moyenne main try ValueError convertirquitté ValueError moyennequitté rattrapée chaque cadre sans try est quitté

Où l’image s’arrête : l’apprenti pourra revenir plus tard avec des œufs.

Une fonction quittée par une exception est terminée pour de bon : son travail en cours est perdu.

Suis l’exception dans notes.py

Une note a été tapée avec une virgule. Les lignes s’allument au fil de l’exécution ; en haut à droite, la pile d’appels.

notes.pyPython
def convertir(texte):    return float(texte)def moyenne(textes):    total = 0    for t in textes:        total += convertir(t)    return total / len(textes)def main():    try:        print(moyenne(["4.5", "5,5", "6"]))    except ValueError as e:        print("Note illisible :", e)main()

main() est appelée (tout en bas du fichier) : son cadre s’empile sur celui du programme principal. main entre dans son bloc try.

moyenne est appelée : nouveau cadre. La note « 4.5 » est déjà comptée, total vaut 4.5 ; vient le tour de « 5,5 ».

convertir("5,5") est appelée : un quatrième cadre s’empile, au sommet de la pile.

float("5,5") lève ValueError : la virgule n’est pas comprise. convertir n’a pas de try : elle est interrompue.

Le cadre de convertir est retiré. L’exception arrive dans moyenne, à la ligne de l’appel. Pas de try ici non plus.

moyenne est quittée en pleine boucle : la note « 6 » ne sera jamais lue, total est perdu et son return ne s’exécute jamais.

Rattrapée ! L’appel se trouvait dans le try de main, avec except ValueError. main affiche le message et continue.

Et sans ce try ? main et le programme principal seraient quittés aussi : le programme s’arrête et affiche la trace.

Réponse à ma question du début : c’est le premier appelant qui a un try adapté qui réagit.

Et les fonctions du milieu ?

Elles sont simplement quittées, sans rien faire de plus. Comme la boulangère, elles abandonnent leur travail en cours.

La trace, c’est la pile

Sans le try, main serait quittée à son tour. La trace affichée à l’arrêt montre la pile au moment de l’erreur : un « File … in … » par cadre traversé.

Traceback (…): File … in <module> File … in main File … in moyenne File … in convertir ValueError: … convertir moyenne main <module> le sommet de la pile est écrit en dernier

Python écrit le plus récent en dernier : « most recent call last ».

La même trace en Python et en Java

Python écrit le cadre le plus récent en dernier, Java en premier.

Trace Python, main sans try (chemins raccourcis)
Traceback (most recent call last):
  File "notes.py", line 13, in <module>
    main()
    ~~~~^^
  File "notes.py", line 11, in main
    print(moyenne(["4.5", "5,5", "6"]))
          ~~~~~~~^^^^^^^^^^^^^^^^^^^^^
  File "notes.py", line 7, in moyenne
    total += convertir(t)
             ~~~~~~~~~^^^
  File "notes.py", line 2, in convertir
    return float(texte)
ValueError: could not convert string to float: '5,5'

Python écrit les cadres du plus ancien au plus récent (« most recent call last ») : le dernier « File » est l'endroit où l'exception est née, juste au-dessus du message.

JavaNotes.java
public class Notes {
    static double convertir(String texte) {
        return Double.parseDouble(texte);
    }

    static double moyenne(String[] textes) {
        double total = 0;
        for (String t : textes) {
            total += convertir(t);
        }
        return total / textes.length;
    }

    public static void main(String[] args) {
        String[] notes = {"4.5", "5,5", "6"};
        System.out.println(moyenne(notes));
    }
}
Stack trace Java
Exception in thread "main" java.lang.NumberFormatException: For input string: "5,5"
	at java.base/jdk.internal.math.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:2054)
	at java.base/jdk.internal.math.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
	at java.base/java.lang.Double.parseDouble(Double.java:792)
	at Notes.convertir(Notes.java:3)
	at Notes.moyenne(Notes.java:9)
	at Notes.main(Notes.java:16)

Java fait l'inverse : l'appel le plus récent en premier, juste sous le message. Les premières lignes viennent de la bibliothèque Java ; cherche la première qui parle de ton code, ici Notes.convertir, ligne 3.

Exercice 3

Qui la rattrape ?

Touche la bonne réponse.

def c():
    raise ValueError("oups")

def b():
    c()
    print("b continue")

def a():
    try:
        b()
    except ValueError:
        print("a rattrape")

a()
try:
    {"Léa": 5.5}["Tom"]
except IndexError:
    print("indice")
except LookupError:
    print("recherche")
except Exception:
    print("autre")

Dans une trace Python, la ligne « File » juste au-dessus du message désigne…

Dire non, proprement

Dans la vraie vie

Au distributeur, tu demandes 50 CHF. Ton compte n’en contient que 20.

Solde : 20 CHF Retrait : 50 CHF Refusé il manque 30 CHF aucun billet

Il ne te donne pas 20 CHF en silence, et il ne plante pas non plus : il refuse, avec un message clair.

raise / throw

Une fonction peut refuser une demande absurde de la même façon : elle lève une exception avec raise (Python) ou throw (Java, JavaScript), au lieu de renvoyer une valeur bizarre que personne ne vérifiera.

retirer(20, 50) retirer 50 > 20 pas de return SoldeInsuffisant il manque 30 CHF elle lève, au lieu de renvoyer

Pour un cas propre à ton programme, crée ta classe d’exception : elle hérite de la classe Exception2.

class SoldeInsuffisant(Exception):
    """Retrait supérieur au solde."""

Le nom dit déjà ce qui ne va pas.

La banque, en trois langages

La même fonction retirer en Python, Java et JavaScript : un retrait trop grand lève une exception.

Pythonbanque.py
class SoldeInsuffisant(Exception):
    """Retrait supérieur au solde."""

def retirer(solde, montant):
    if montant <= 0:
        raise ValueError(f"montant invalide : {montant}")
    if montant > solde:
        manque = montant - solde
        raise SoldeInsuffisant(f"il manque {manque} CHF")
    return solde - montant

try:
    retirer(20, 50)
except SoldeInsuffisant as e:
    print("Refusé :", e)
# Refusé : il manque 30 CHF
JavaBanque.java
// Dans son propre fichier, SoldeInsuffisantException.java
public class SoldeInsuffisantException extends Exception {
    public SoldeInsuffisantException(String message) {
        super(message);
    }
}

// Dans la classe Banque
static double retirer(double solde, double montant)
        throws SoldeInsuffisantException {
    if (montant <= 0) {
        throw new IllegalArgumentException("montant invalide : " + montant);
    }
    if (montant > solde) {
        throw new SoldeInsuffisantException("il manque " + (montant - solde) + " CHF");
    }
    return solde - montant;
}

// Dans main
try {
    retirer(20, 50);
} catch (SoldeInsuffisantException e) {
    System.out.println("Refusé : " + e.getMessage());   // il manque 30.0 CHF
}
JavaScriptbanque.js
class SoldeInsuffisant extends Error {
    constructor(message) {
        super(message);
        this.name = "SoldeInsuffisant";
    }
}

function retirer(solde, montant) {
    if (montant > solde) {
        throw new SoldeInsuffisant(`il manque ${montant - solde} CHF`);
    }
    return solde - montant;
}

try {
    retirer(20, 50);
} catch (e) {
    if (e instanceof SoldeInsuffisant) console.log("Refusé :", e.message);
    else throw e;
}

throw, raise

L’instruction qui lève l’exception : raise en Python, throw en Java et en JavaScript.

throws

Avec un s, dans la signature d’une méthode Java : il annonce les exceptions qu’elle peut laisser passer.

Relancer

Pour relancer l’exception qu’on vient de rattraper : raise tout seul en Python, throw e; en Java et en JavaScript1.

Java trie les exceptions

Java ajoute une règle que Python et JavaScript n’ont pas : les exceptions vérifiées (checked) doivent être rattrapées, ou annoncées avec throws ; les non vérifiées (unchecked) n’imposent rien3.

vérifiée IOException javac try/catch ou throws non vérifiée NullPointerException rien d’obligatoire

Ce que Java vérifie

L’arbre des exceptions Java, branche par branche.

Ce que Java vérifieThrowable

Tout ce qu'on peut lever en Java descend de Throwable, en deux branches : Error et Exception.

Piège Java : la vérifiée oubliée

Ouvre un fichier avec new FileReader(chemin) sans try ni throws, et javac refuse :

error: unreported exception FileNotFoundException; must be caught or declared to be thrown

Ce n’est pas un bug du programme : le compilateur t’oblige à prévoir le cas.

Exercice 4

Vérifiée ou non vérifiée ?

Range chaque exception Java dans la bonne case.

Vérifiéetry/catch ou throws obligatoire
Non vérifiéerien d'obligatoire

La porte se referme toujours

Dans la vraie vie

Dans beaucoup de bâtiments, la porte coupe-feu se referme toute seule derrière toi.

la porte se referme l’alarme sonne toujours

Que tu sortes tranquillement ou en courant parce que l’alarme sonne, elle se ferme. Mais elle n’arrête pas l’alarme.

with

Un fichier ouvert, une connexion : il faut les libérer, même quand une exception interrompt le travail. with ferme le fichier à la sortie du bloc, normale ou par une exception1.

with open(…) as f: ouvert fermé normale exception f.close() suite vers un except

Comme la porte, with ne rattrape pas l’exception : elle continue son chemin.

notes.txt, ouvert puis fermé

Le fichier contient trois lignes : « 4.5 », « 5,5 » et « 6 ». Une erreur survient en plein milieu du bloc with.

  1. try:
  2. with open("notes.txt") as f:
  3. for ligne in f:
  4. print(float(ligne.strip()))
  5. except ValueError as e:
  6. print("Erreur :", e)
  7. print("Fichier fermé :", f.closed)

1. with open(…) ouvre notes.txt. Le fichier reste ouvert tant qu'on est dans le bloc.

2. Première ligne, « 4.5 ». float la convertit : 4.5 s'affiche.

3. Deuxième ligne, « 5,5 ». ValueError, en plein milieu du bloc with.

4. with ferme le fichier avant de laisser passer l'exception, puis except l'affiche. f.closed vaut True.

with, try-with-resources, finally, defer

La même garantie en Python, Java, JavaScript (Node) et Go.

Pythonwith
with open("notes.txt", encoding="utf-8") as f:
    for ligne in f:
        print(float(ligne))
# f est fermé à la sortie du bloc,
# même si une exception est levée

# la même chose, à la main :
f = open("notes.txt", encoding="utf-8")
try:
    for ligne in f:
        print(float(ligne))
finally:
    f.close()
Javatry-with-resources
static double somme(String chemin) throws IOException {
    double total = 0;
    try (BufferedReader r = new BufferedReader(new FileReader(chemin))) {
        String ligne;
        while ((ligne = r.readLine()) != null) {
            total += Double.parseDouble(ligne);
        }
    }   // r est fermé ici, même en cas d'exception
    return total;
}
JavaScript (Node)finally
const fs = require("node:fs");
const fd = fs.openSync("notes.txt", "r");
try {
    const lignes = fs.readFileSync(fd, "utf8").trim().split("\n");
    console.log(lignes.map(Number));
    // [ 4.5, NaN, 6 ]
} finally {
    fs.closeSync(fd);
}
Godefer
func lire(chemin string) error {
    f, err := os.Open(chemin)
    if err != nil {
        return err
    }
    // exécuté à la sortie de lire,
    // quoi qu'il arrive
    defer f.Close()
    // ... lecture ligne par ligne
    return nil
}

Python : with

À la sortie du bloc, normale ou par une exception, le fichier est fermé1.

Java : try-with-resources

Toute ressource AutoCloseable déclarée dans le try est fermée à la fin, qu’il se termine normalement ou brutalement4.

Go : defer

defer programme l’appel pour la fin de la fonction, y compris pendant un panic6.

Mais attention

Aucun des trois ne rattrape l’exception : elle continue son chemin vers un except.

Une exception est une information

Une exception n’est pas une ennemie.

C’est une information. Le but n’est pas de toutes les faire taire, mais de réagir là où l’on sait quoi faire.

Dans la vraie vie

Ton détecteur de fumée bipe. Tu enlèves la pile : le bruit s’arrête.

bip, bip plus de bruit… … mais le feu continue

Le calme revient. Mais s’il y a vraiment un feu, plus personne ne sera prévenu.

except: pass

Un bloc vide, except: pass ou catch (e) {}, c’est la pile retirée : l’erreur disparaît, et le programme continue avec des données fausses.

try: m = calcul(notes) except: pass ValueError la suite tourne avec des données fausses

Et personne ne saura ce qui s’est passé.

Rattrape l’exception précise

Celle que tu sais traiter, ValueError pour une saisie par exemple, pas Exception « au cas où ».

Place le try là où tu peux réagir

Redemander une saisie, afficher un message, annuler l’opération. Ailleurs, laisse remonter.

Jamais de bloc vide

except: pass ou catch (e) {} fait disparaître l’erreur : le programme continue avec des données fausses.

Lève tôt, avec un message clair

raise ValueError(f"montant invalide : {montant}") vaut mieux qu’un résultat faux dix lignes plus loin.

Ferme les ressources

Avec with, try-with-resources ou defer.

Exercice 5

Bon réflexe ou mauvaise idée ?

Range chaque habitude dans la bonne case.

Bon réflexel'erreur reste visible
Mauvaise idéel'erreur se cache
Exercice 6

Redemande jusqu'à obtenir un nombre

Remets les lignes dans l'ordre. Le programme redemande tant que la saisie n'est pas un entier, puis affiche Merci : 12 quand on tape 12.

  1. while True:
  2. texte = input("Un nombre : ")
  3. try:
  4. n = int(texte)
  5. except ValueError:
  6. print("Ce n'est pas un nombre.")
  7. else:
  8. break
  9. print("Merci :", n)

La fiche en six cartes

L’exception

Un objet qui signale une erreur à l’exécution. Non rattrapée, elle arrête le programme, qui affiche une trace : lis d’abord la dernière ligne.

try, except, else, finally

La première exception abandonne le reste du try ; Python saute au premier except qui correspond. else seulement sans exception, finally dans tous les cas.

Les familles

Un except rattrape son type et tous ses descendants : écris-les du plus précis au plus général.

La pile d’appels

Non rattrapée, l’exception remonte la pile, cadre par cadre, jusqu’au premier try adapté. Les fonctions traversées sont quittées.

Lever

raise en Python, throw en Java et en JavaScript ; ta classe hérite d’Exception. En Java, une exception vérifiée doit être rattrapée ou déclarée avec throws.

Ranger

with, try-with-resources et defer ferment la ressource même en cas d’exception, sans la rattraper.

Dix questions, une seule vie

Mode survie

Dix questions tirées au hasard, de plus en plus difficiles. À la première erreur, la partie s’arrête : lis l’explication, puis relance.

Mon conseil : pour chaque question, cherche où naît l’exception, puis quel est le premier try capable de la rattraper.

10 questions · zéro faute · chronomètre

Sources

  1. Python Software Foundation, Le tutoriel Python : Erreurs et exceptions (try, except, else, finally, raise, exceptions personnalisées, with), documentation Python 3, consultée en 2026. docs.python.org
  2. Python Software Foundation, Exceptions natives (hiérarchie des exceptions, BaseException et Exception), documentation Python 3, consultée en 2026. docs.python.org
  3. Oracle, The Java Tutorials : The Catch or Specify Requirement (exceptions vérifiées, erreurs, exceptions d'exécution), consulté en 2026. docs.oracle.com
  4. Oracle, The Java Tutorials : The try-with-resources Statement, consulté en 2026. docs.oracle.com
  5. MDN, try...catch (les trois formes, un seul catch, instanceof, finally), consulté en 2026. developer.mozilla.org
  6. Andrew Gerrand, Defer, Panic, and Recover, The Go Blog, 4 août 2010, consulté en 2026. go.dev

Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Extraits exécutés : Python 3.14, Java 21, Node 25 ; les traces et les messages d'erreur sont recopiés de ces exécutions (chemins de fichiers raccourcis). Extraits Go relus (compilateur non disponible).

Glisser pour continuer vers Prog 12 : Fichiers
Gymnase 3