Texte qui n’est pas un nombre
- Python
ValueError- Java
NumberFormatException- JavaScript
- aucune :
NaN
Programmation · Prog 11 · Les imprévus
Ce qui se passe quand un programme tombe sur un imprévu, et comment le prévoir.
Déjà à l'aise ? Aller directement au quizDans la vraie vie
Mardi, 10 h 15, cours de maths. L’alarme incendie se met à sonner.
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.
Celle qui plante ?
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.
Si personne ne la rattrape, le programme abandonne tout et affiche une trace.
Regarde ce programme recevoir « douze » au lieu d’un nombre.
Cinq lignes et une valeur inattendue : regarde ce que devient la suite.
Cinq lignes, que Python va exécuter une par une, de haut en bas.
Pas la première ?
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.
ValueErrorNumberFormatExceptionNaNIndexErrorIndexOutOfBoundsExceptionundefinedKeyErrorget renvoie nullundefinedZeroDivisionErrorArithmeticException, entiers seulementInfinityAttributeError sur NoneNullPointerExceptionTypeErrorFileNotFoundErrorFileNotFoundExceptionENOENTPiège JavaScript
L’erreur qui passe en silence : parseFloat("5,5") donne 5. Il s’arrête à la virgule, sans rien signaler.
Pareil : Number("douze") donne NaN, 10 / 0 donne Infinity. Teste la valeur (Number.isNaN) ou lève toi-même une erreur.
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.
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.
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.
finally sert à ranger, quoi qu’il arrive.
D’abord avec « 12 », puis avec « douze » : regarde quels blocs s’exécutent.
Premier passage : texte vaut « 12 ». Python entre dans le bloc try et exécute int(texte).
Le code qui risque d’échouer. À la première exception, la suite du bloc est abandonnée.
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.
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.
Dans tous les cas, même quand la fonction quitte le bloc par un return.
lire_age en Python, Java, JavaScript et Go. Regarde la sortie : finally s’exécute même après un return.
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"))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"));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"));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)
}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.
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.
Python 3.14 affiche désormais un avertissement :
SyntaxWarning: 'return' in a 'finally' block
Garde finally pour ranger, pas pour renvoyer.
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.
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.
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.
Une division par zéro, une clé absente, puis un texte illisible : chacune teste les except de haut en bas.
Trois except, du plus précis au plus général. En haut, la famille des exceptions concernées.
Un tuple en Python, une barre verticale en Java, un test instanceof dans l’unique catch de JavaScript.
notes = {"Léa": 5.5}
try:
print(notes["Tom"] / 2)
except (KeyError, ZeroDivisionError) as e:
print("Calcul impossible :", repr(e))
# Calcul impossible : KeyError('Tom')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 zerotry {
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.
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.
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.
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.
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.
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.
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.
Et les fonctions du milieu ?
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é.
Python écrit le plus récent en dernier : « most recent call last ».
Python écrit le cadre le plus récent en dernier, Java en premier.
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.
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));
}
}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.
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.
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.
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 même fonction retirer en Python, Java et JavaScript : un retrait trop grand lève une exception.
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// 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
}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;
}L’instruction qui lève l’exception : raise en Python, throw en Java et en JavaScript.
Avec un s, dans la signature d’une méthode Java : il annonce les exceptions qu’elle peut laisser passer.
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.
L’arbre des exceptions Java, branche par branche.
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.
Range chaque exception Java dans la bonne case.
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.
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.
Comme la porte, with ne rattrape pas l’exception : elle continue son chemin.
Le fichier contient trois lignes : « 4.5 », « 5,5 » et « 6 ». Une erreur survient en plein milieu du bloc with.
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.
La même garantie en Python, Java, JavaScript (Node) et Go.
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()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;
}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);
}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
}À la sortie du bloc, normale ou par une exception, le fichier est fermé1.
Toute ressource AutoCloseable déclarée dans le try est fermée à la fin, qu’il se termine normalement ou brutalement4.
defer programme l’appel pour la fin de la fonction, y compris pendant un panic6.
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.
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.
Et personne ne saura ce qui s’est passé.
Celle que tu sais traiter, ValueError pour une saisie par exemple, pas Exception « au cas où ».
Redemander une saisie, afficher un message, annuler l’opération. Ailleurs, laisse remonter.
except: pass ou catch (e) {} fait disparaître l’erreur : le programme continue avec des données fausses.
raise ValueError(f"montant invalide : {montant}") vaut mieux qu’un résultat faux dix lignes plus loin.
Avec with, try-with-resources ou defer.
Range chaque habitude dans la bonne case.
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.
La fiche en six cartes
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.
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.
Un except rattrape son type et tous ses descendants : écris-les du plus précis au plus général.
Non rattrapée, l’exception remonte la pile, cadre par cadre, jusqu’au premier try adapté. Les fonctions traversées sont quittées.
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.
with, try-with-resources et defer ferment la ressource même en cas d’exception, sans la rattraper.
Dix questions, une seule vie
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.
10 questions · zéro faute · chronomètre
Les vidéos de Graven, en français, sur les exceptions en Java et en Python.
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).