Fichiers et exceptions en Python

Un fichier texte conserve des informations après l’arrêt d’un programme. Python utilise un objet fichier, renvoyé par open(), pour manipuler ces informations. L’ouverture établit la connexion avec le fichier ; une opération de lecture récupère son texte.

Choisir ce qu’il faut lire

Le mode par défaut est "r", pour la lecture. Un nom seul est recherché dans le répertoire de travail courant. Si le fichier y est absent, open() lève FileNotFoundError.

with open("fruit.txt", encoding="utf-8") as f:
    text = f.read()

Supposons que le fichier contienne trois lignes, « apple », « banana » et « cherry », toutes avec une fin de ligne. text vaut 'apple\nbanana\ncherry\n'. La séquence d’échappement \n représente un seul caractère de saut de ligne. Une dernière ligne peut aussi se terminer sans saut de ligne.

readline() renvoie '' à la fin du fichier. Une ligne vide qui possède une fin de ligne renvoie '\n' : une ligne vide et la fin du fichier sont donc deux choses différentes.

Suivre la position

La lecture fait avancer la position dans le fichier. Après que f.read() a lu tout le fichier, un autre appel renvoie '' ; une boucle sur ce même objet n’a plus rien à parcourir. Rouvre le fichier pour recommencer ou conserve le texte ou les lignes nécessaires dans une variable. read() et readlines() chargent le reste du fichier en mémoire. Parcourir directement le fichier permet de traiter un gros fichier ligne par ligne.

Les lignes conservent leurs caractères de saut de ligne. print(line) ajoute son propre saut de ligne, ce qui peut laisser des lignes vides supplémentaires à l’écran. Utilise print(line, end="") pour conserver l’espacement d’origine, ou supprime la fin de ligne avant l’affichage. line.rstrip("\n") supprime les sauts de ligne finaux ; line.strip() supprime aussi les espaces aux deux extrémités.

Transformer du texte en nombres

Même les chiffres arrivent sous forme de chaînes. Ce fichier contient les notes « 72 », « 85 » et « 90 » :

scores = []
with open("scores.txt", encoding="utf-8") as f:
    for line in f:
        scores.append(int(line))
total = sum(scores)
print(total, round(total / len(scores), 2))

La liste est [72, 85, 90], donc le programme affiche 247 82.33. int() accepte les espaces et les sauts de ligne qui entourent les chiffres. Une chaîne vide ou un mot tel que "forty" lève ValueError.

Lire les caractères avec le bon encodage

Un encodage associe les caractères aux octets stockés. UTF-8 peut représenter des caractères tels que « é » et les émojis. Utilise explicitement encoding="utf-8" pour les fichiers UTF-8. Python 3.15 active le mode UTF-8 par défaut ; les installations plus anciennes peuvent utiliser un encodage local. Un encodage incorrect peut produire un texte déformé ou une UnicodeDecodeError. Indiquer explicitement l’encodage ne convertit pas en UTF-8 un fichier enregistré dans un autre encodage.

Le bloc with ferme le fichier lorsqu’il se termine. Un fichier fermé ne peut pas être lu : un nouvel appel à f.read() lève ValueError.

Un fichier ouvert utilise des ressources du système d’exploitation. Le texte en cours d’écriture peut aussi attendre dans un tampon en mémoire avant d’atteindre le fichier. La fermeture libère les ressources et vide le tampon d’écriture. Une instruction with organise ce nettoyage à un endroit clair du code.

Lire dans le bloc, utiliser le résultat ensuite

with open("notes.txt", encoding="utf-8") as f:
    text = f.read()
print(len(text))

Les deux-points commencent le bloc. La ligne indentée s’exécute pendant que f est ouvert. Lorsque l’exécution atteint le print() non indenté, le fichier est fermé, mais text reste une chaîne ordinaire. Le nom f désigne toujours l’objet fichier ; f.closed vaut maintenant True.

Le même schéma fonctionne pour une liste :

with open("fruit.txt", encoding="utf-8") as f:
    lines = f.readlines()
for line in lines:
    print(line.strip().upper())

La boucle utilise les données déjà lues dans lines. Déplacer f.readlines() hors du bloc tenterait de lire un fichier fermé et lèverait ValueError.

Nettoyer lorsque l’exécution change de direction

Considère une fonction qui renvoie la première ligne :

def first_line(path):
    with open(path, encoding="utf-8") as f:
        return f.readline().rstrip("\n")

La valeur de retour est préparée dans le bloc. Python quitte ensuite le bloc et ferme le fichier avant que l’appelant reçoive cette valeur. Le fichier se ferme aussi lorsqu’une exception quitte le bloc. Un f.close() manuel placé après une instruction qui échoue ne serait jamais atteint.

Les objets fichier permettent ce comportement parce qu’ils sont des gestionnaires de contexte : des objets qui organisent la mise en place et le nettoyage autour d’un bloc with. Tu peux utiliser ce comportement sans écrire toi-même un gestionnaire de contexte.

Ouvrir ensemble un fichier d’entrée et un fichier de sortie

with open("in.txt", encoding="utf-8") as src, open("out.txt", "w", encoding="utf-8") as dst:
    for line in src:
        dst.write(line.upper())

Chaque ligne d’entrée est convertie en majuscules et écrite dans le fichier de sortie. Les deux fichiers se ferment à la fin du bloc. Si la seconde ouverture échoue, le premier fichier, déjà pris en charge par with, est fermé lorsque Python quitte l’instruction.

Le nettoyage et la gestion des erreurs ont des rôles différents

with n’intercepte pas les erreurs de fichier. Si open() ne trouve pas notes.txt, il lève FileNotFoundError avant l’exécution du corps. Si la conversion d’une ligne avec int() échoue dans le corps, le fichier se ferme et l’exception poursuit sa propagation. Une clause except correspondante est nécessaire pour reprendre le traitement ou afficher un message.

L’absence des deux-points à la fin de la ligne with provoque une SyntaxError.

L’écriture commence par un choix concernant les données existantes. Le mode détermine si Python lit, remplace, complète ou crée un fichier. Fais ce choix avant d’appeler open(), car le remplacement est immédiat.

Choisir le mode

Ouvrir l’unique copie de données importantes avec "w" détruit son ancien contenu, même si aucun write() ne suit. Utilise un fichier de sortie distinct pendant que tu apprends à transformer des données. "x" est utile lorsqu’il faut refuser le remplacement d’un fichier existant.

Ajouter "b", comme dans "rb", sélectionne le mode binaire pour les octets bruts. Les modes texte utilisent des chaînes et un encodage ; les modes binaires n’acceptent pas d’argument encoding.

Décider où les lignes se terminent

with open("todo.txt", "w", encoding="utf-8") as f:
    f.write("buy milk\n")
    f.write("call Sam\n")

Le fichier contient les deux lignes « buy milk » et « call Sam ». write() ajoute exactement la chaîne fournie, sans séparateur automatique. Sans les sauts de ligne, le fichier contiendrait "buy milkcall Sam" sur une seule ligne.

write() renvoie le nombre de caractères écrits. Par exemple, f.write("Ana,92\n") renvoie 7. C’est un nombre de caractères, qui ne correspond pas nécessairement au nombre d’octets encodés sur le disque. La méthode accepte une chaîne ; f.write(42) lève TypeError. Convertis d’abord un nombre, par exemple avec f.write(f"{score}\n").

Comparer les outils d’écriture

print() peut écrire dans un fichier :

with open("total.txt", "w", encoding="utf-8") as f:
    print("Total:", 247, file=f)

Le texte écrit est "Total: 247\n". print() convertit ses arguments, les sépare par des espaces et ajoute par défaut un saut de ligne final.

writelines() prend une séquence de chaînes, mais n’insère aucune fin de ligne. f.writelines(["a", "b"]) écrit "ab". Pour obtenir un élément par ligne, inclus un saut de ligne dans chaque chaîne ou assemble les chaînes avec "\n" et ajoute un saut de ligne final.

Conserver les exécutions précédentes

with open("log.txt", "a", encoding="utf-8") as f:
    f.write("Program started\n")

En partant sans fichier, deux exécutions produisent deux lignes. Avec "w", chaque exécution remplacerait l’entrée précédente. Le mode ajout ne fournit pas de saut de ligne manquant : si le texte existant se termine au milieu d’une ligne, le nouveau texte commence immédiatement après.

Pour un rapport, parcours des paires telles que [("Ana", 92), ("Ben", 78)] et écris f"{name}: {score}\n". La mise en forme a lieu avant l’écriture : f"{82.333:.1f}" produit donc le texte "82.3". with ferme ensuite le fichier de sortie et vide le tampon de texte à la fin du bloc.

De nombreuses tâches sur les fichiers consistent en une boucle contenant une décision. Lis une ligne, supprime les espaces indésirables, décide si elle t’intéresse et mets à jour un résultat. Séparer ces étapes rend le programme plus facile à vérifier.

Parcourir un journal

Supposons que server.log contienne ces enregistrements, avec une ligne vide avant le dernier :

2026-03-01 08:14 INFO Server started
2026-03-01 08:20 ERROR Disk almost full
2026-03-01 09:02 INFO User login: maya
2026-03-01 09:15 WARNING Slow response
2026-03-01 10:40 ERROR Database timeout

2026-03-01 11:05 INFO Backup finished

Chaque enregistrement non vide comporte une date, une heure, un niveau et un message. Découpe seulement trois fois pour garder le message d’un seul tenant :

errors = 0
with open("server.log", encoding="utf-8") as f:
    for line in f:
        line = line.strip()
        if not line:
            continue
        parts = line.split(maxsplit=3)
        if parts[2] == "ERROR":
            errors += 1
            print(parts[3])
print(errors, "errors")

Pour le deuxième enregistrement, parts[2] vaut "ERROR" et parts[3] vaut "Disk almost full". Ce message s’affiche et le compteur passe à 1. L’erreur suivante le fait passer à 2. Le programme affiche les deux messages, puis « 2 errors ».

Rechercher dans la partie voulue

Une recherche n’importe où trouverait aussi « INFO No ERRORS today ». Vérifier le champ du niveau répond plus précisément à la question posée sur le journal.

Après strip(), une ligne vide vaut "" ; son découpage donne []. Accéder alors à parts[2] lèverait IndexError. L’instruction continue passe cette ligne avant tout accès par indice. Un enregistrement non vide mais incomplet nécessite aussi une vérification de sa longueur lorsque de tels enregistrements sont possibles.

Compter les catégories ou écrire un fichier filtré

Un dictionnaire conserve un compteur par niveau. Pour chaque enregistrement, affecte level = parts[2], puis exécute counts[level] = counts.get(level, 0) + 1. Pour le journal ci-dessus, les comptes sont {'INFO': 3, 'ERROR': 2, 'WARNING': 1}. La valeur par défaut 0 initialise une catégorie lors de sa première apparition.

Pour enregistrer les enregistrements correspondants, ouvre un fichier de destination distinct dans la même instruction with et écris une ligne lorsque son niveau correspond. Conserve la line d’origine si les espaces comptent ; si tu écris du texte nettoyé, rétablis son saut de ligne. N’ouvre jamais la source elle-même avec "w" : elle serait vidée avant le début de la lecture.

Voir les caractères invisibles

print(repr(line)) rend visibles les espaces finaux et les sauts de ligne, par exemple 'Disk full \n'. strip() supprime les deux, tandis que rstrip("\n") conserve les espaces. La lecture normale en mode texte transforme les fins de ligne Windows, Unix et ancien Mac reconnues en "\n". Une dernière ligne sans fin de ligne reste sans fin de ligne. Un nom de fichier recueilli avec input("File name: ").strip() permet à la même boucle de fonctionner avec différents fichiers d’entrée.

Un chemin décrit un emplacement dans une arborescence de dossiers. Il peut commencer à la racine de cette arborescence ou au répertoire de travail courant du programme. Un fichier peut exister sur l’ordinateur tout en étant absent à l’emplacement demandé par ton programme.

Lire un chemin à partir de son point de départ

Supposons qu’un dossier nommé project contienne un dossier scripts et un dossier data. Tu exécutes python scripts/report.py depuis project. L’ouverture de "data/notes.txt" cherche dans project/data, même si le script se trouve dans project/scripts.

Si tu lances le même script depuis project/scripts, ce chemin relatif pointe alors vers l’intérieur de project/scripts/data. Le script n’a pas bougé ; le point de départ a changé.

from pathlib import Path
print(Path.cwd())

Ce code affiche le répertoire de travail courant. os.getcwd() après import os fournit la même information sous forme de chaîne. Les éditeurs et les outils de lancement peuvent choisir un répertoire de travail : examine-le donc lorsque l’emplacement n’est pas clair.

Parcourir les dossiers

Dans un chemin relatif, . désigne le dossier courant et .. son parent. Depuis project/scripts, ../data/notes.txt remonte à project, puis descend dans data. Ajouter .. sans vérifier le dossier de départ peut envoyer un programme au mauvais endroit.

Un chemin absolu est utile pour désigner un emplacement précis, mais un chemin tel que C:/Users/Maya/Desktop/data.csv lie le code partagé aux dossiers d’une seule personne. Utilise un chemin relatif avec un point de départ clair, ou construis-le à partir du dossier du script lorsque c’est là que se trouvent les données.

Conserver les barres obliques inverses de Windows

Windows affiche généralement des barres obliques inverses entre les dossiers. Dans une chaîne Python ordinaire, une barre oblique inverse commence une séquence d’échappement : \n devient un saut de ligne et \t une tabulation. Le littéral "C:\new\table.txt" ne contient donc pas le chemin souhaité.

Ces formes conservent le chemin voulu :

raw = r"C:\new\table.txt"
escaped = "C:\\new\\table.txt"
forward = "C:/new/table.txt"

Python sous Windows accepte les barres obliques. Une chaîne brute empêche les barres obliques inverses de devenir des séquences d’échappement, mais elle ne peut pas se terminer par une seule barre oblique inverse. Par exemple, r"C:\data\" est une syntaxe invalide.

Vérifier le nom autant que le dossier

Cherche les différences d’orthographe et les extensions masquées : un fichier affiché sous le nom « notes.txt » peut en réalité s’appeler « notes.txt.txt ». La casse compte aussi. Linux distingue généralement Data.csv de data.csv ; les configurations habituelles de Windows et de macOS ne les distinguent pas. Respecter la casse réelle permet au projet de rester utilisable sur différents systèmes.

Le module standard pathlib donne au chemin son propre objet. Un objet Path permet d’assembler des noms de dossiers, d’examiner un nom de fichier et d’effectuer des tâches courantes sur les fichiers sans construire manuellement des chaînes de séparateurs.

Assembler et examiner

from pathlib import Path
p = Path("reports") / "2026" / "sales.csv"
print(p.name)
print(p.stem)
print(p.suffix)
print(p.parent)

Les trois premiers résultats sont « sales.csv », « sales » et « .csv ». Le parent est le chemin reports/2026, affiché avec le séparateur du système. Ici, / assemble des parties de chemin ; il ne divise pas des nombres. L’ancienne fonction os.path.join() assemble aussi des parties de chemin sous forme de chaînes.

Un objet Path décrit un emplacement même avant que quoi que ce soit y existe. p.exists() vérifie si quelque chose existe à cet emplacement. p.is_file() et p.is_dir() distinguent un fichier d’un répertoire. Une vérification de l’existence ne peut pas garantir une ouverture ultérieure : le fichier peut disparaître ou les droits d’accès peuvent changer entre les deux opérations. Gère les erreurs d’ouverture lorsque le programme doit pouvoir reprendre le traitement.

Lire ou écrire un petit fichier

open() accepte directement un objet Path. Pour un petit fichier, ces méthodes gèrent aussi l’ouverture et la fermeture :

p = Path("greeting.txt")
p.write_text("Hello\n", encoding="utf-8")
text = p.read_text(encoding="utf-8")

text devient "Hello\n". write_text() remplace le contenu existant, comme une ouverture avec "w" ; cette méthode ne sert pas à ajouter du texte. read_text() charge tout le fichier : utilise donc une boucle sur le fichier lorsque tu dois traiter un gros fichier ligne par ligne.

Partir du dossier du script

Un fichier de données fourni à côté d’un script doit être localisé à partir de ce script, indépendamment du répertoire de travail :

base = Path(__file__).resolve().parent
scores_path = base / "data" / "scores.txt"
with open(scores_path, encoding="utf-8") as f:
    scores = f.readlines()

__file__ désigne le fichier du script. resolve() rend son chemin absolu et parent sélectionne le dossier qui le contient. Dans une console interactive, __file__ n’est pas défini : ce schéma s’utilise donc dans un script.

Trouver des fichiers et préparer des dossiers de sortie

for p in sorted(Path("logs").glob("*.txt")):
    text = p.read_text(encoding="utf-8")
    print(p.name, len(text.splitlines()))

glob("*.txt") sélectionne les chemins correspondants dans logs. iterdir() produit les entrées du dossier sans ce filtre par motif. Le tri rend l’ordre prévisible. splitlines() compte les lignes de texte sans traiter la fin de ligne finale comme une ligne vide supplémentaire.

L’écriture crée un fichier, mais pas les dossiers parents manquants. Prépare-les d’abord :

folder = Path("output") / "daily"
folder.mkdir(parents=True, exist_ok=True)
(folder / "report.txt").write_text("Ready\n", encoding="utf-8")

parents=True crée les dossiers manquants au-dessus de daily. exist_ok=True accepte un répertoire déjà existant. Cela ne transforme pas un fichier ordinaire existant en dossier.

Un fichier CSV stocke un tableau sous forme de texte. Ses enregistrements sont des lignes et ses champs sont des valeurs de colonnes. Les virgules séparent généralement les champs, mais les champs entre guillemets peuvent contenir des virgules et même des sauts de ligne. Utilise le module csv pour garder ces valeurs ensemble.

Laisser un objet reader gérer les guillemets

name,quiz1,quiz2
Ana,8,9
Ben,7,6
"Lopez, Maria",10,8

La première ligne est un en-tête qui contient les noms des colonnes. La dernière ligne de données comporte trois champs, et non quatre : la virgule dans le nom entre guillemets fait partie du nom. Un guillemet double à l’intérieur d’un champ entre guillemets est écrit deux fois. Découper chaque ligne avec split(",") ignorerait ces règles et couperait le nom en morceaux.

import csv
with open("grades.csv", newline="", encoding="utf-8") as f:
    reader = csv.reader(f)
    header = next(reader)
    for row in reader:
        average = (int(row[1]) + int(row[2])) / 2
        print(row[0], average)

L’objet reader renvoie des listes de chaînes. next(reader) consomme l’en-tête une fois, laissant la boucle traiter les données. Le programme affiche « Ana 8.5 », « Ben 6.5 » et « Lopez, Maria 9.0 ». Dans la première ligne de données, la conversion de "8" et "9" donne un total de 17, puis la division par 2 donne 8,5.

Coordonner la gestion du fichier et l’analyse du tableau

Ouvre les fichiers CSV avec newline="" afin que le module csv gère lui-même les fins de ligne. C’est important lorsqu’un champ entre guillemets contient un saut de ligne. Un enregistrement CSV peut s’étendre sur plusieurs lignes physiques du fichier : un découpage ligne par ligne ne remplace donc pas un objet reader CSV.

Par défaut, l’objet reader laisse les valeurs sous forme de chaînes. Sans conversion, l’addition row[1] + row[2] assemble "8" et "9" en "89". Oublier de passer l’en-tête conduit plutôt à essayer de convertir "quiz1" et lève ValueError.

Si un fichier risque d’être vide, next(reader, None) consomme l’en-tête s’il est présent et renvoie None sinon. Une ligne CSV complètement vide devient []. Passe ces lignes avec if not row: continue avant tout accès par indice. Une ligne non vide contenant trop peu de champs nécessite aussi une vérification de sa longueur ; passer uniquement les lignes vides ne protège pas row[2] contre tous les enregistrements trop courts.

S’adapter au format du fichier

reader = csv.reader(f, delimiter=";", skipinitialspace=True)

Ce code choisit les points-virgules comme séparateurs et supprime les espaces qui les suivent immédiatement. Choisis le séparateur réellement utilisé par le fichier ; changer le séparateur ne transforme pas les virgules décimales en points décimaux. float("2,50") lève toujours ValueError.

Certains fichiers exportés par des tableurs commencent par un indicateur d’ordre des octets UTF-8. Les lire avec encoding="utf-8" peut laisser "\ufeff" au début du premier champ et transformer l’en-tête "name" en "\ufeffname". Pour ce format, encoding="utf-8-sig" supprime le marqueur ; cet encodage peut aussi lire les fichiers UTF-8 qui n’en contiennent pas.

Un objet writer CSV transforme les valeurs en champs correctement séparés et mis entre guillemets. Fournis-lui des lignes sous forme de séquences de valeurs et laisse-le gérer la ponctuation. Cela évite une sortie qui semble correcte jusqu’à ce qu’un nom ou un message contienne une virgule.

Écrire un en-tête et des données

import csv
with open("summary.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["name", "average"])
    writer.writerow(["Ana", 8.5])
    writer.writerow(["Lopez, Maria", 9.0])

Le fichier contient les lignes name,average, Ana,8.5 et "Lopez, Maria",9.0. L’objet writer convertit les nombres en texte. Il met entre guillemets le nom contenant une virgule et double tout guillemet double à l’intérieur d’un champ entre guillemets. None devient un champ vide : relire le fichier ne permet donc pas de retrouver automatiquement None.

writerow() prend une ligne. writerows() prend une séquence de lignes, par exemple [["Ana", 8.5], ["Ben", 6.5]]. Passer directement "Ana" à writerow() lui donne en revanche trois caractères et produit A,n,a. Utilise ["Ana"] pour une ligne à un champ.

Confier les fins de ligne au module CSV

Utilise newline="" à l’ouverture du fichier de sortie. Par défaut, l’objet writer termine les enregistrements par "\r\n". Autoriser aussi la conversion des sauts de ligne en mode texte peut ajouter un retour chariot supplémentaire sous Windows et produire des lignes vides indésirables dans certains lecteurs. L’argument newline empêche cette seconde conversion.

Transformer un fichier en un autre

with open("grades.csv", newline="", encoding="utf-8") as src, open("summary.csv", "w", newline="", encoding="utf-8") as dst:
    reader = csv.reader(src)
    writer = csv.writer(dst)
    next(reader)
    writer.writerow(["name", "average"])
    for row in reader:
        average = (int(row[1]) + int(row[2])) / 2
        writer.writerow([row[0], round(average, 2)])

Pour les lignes de notes « Ana,8,9 », « Ben,7,6 » et "Lopez, Maria",10,8, les moyennes sont de 8,5, 6,5 et 9,0. L’objet reader retire les guillemets CSV de la valeur du champ en entrée ; l’objet writer les ajoute de nouveau au besoin en sortie. round() contrôle la valeur numérique écrite, mais n’impose pas l’affichage de deux décimales. Utilise un format tel que f"{average:.2f}" lorsque tu veux exactement deux décimales.

Ajouter sans répéter l’en-tête

Avant d’ouvrir un fichier en mode ajout, vérifie s’il a besoin d’un en-tête :

from pathlib import Path
p = Path("sales.csv")
needs_header = not p.exists() or p.stat().st_size == 0
with open(p, "a", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    if needs_header:
        writer.writerow(["item", "quantity"])
    writer.writerow(["coffee", 4])

Un fichier existant mais vide a lui aussi besoin de son en-tête. Écrire l’en-tête à chaque exécution place les noms des colonnes au milieu des données. Ce schéma suppose qu’un seul programme met le fichier à jour ; vérifier son existence ne le protège pas contre les modifications par d’autres programmes.

Un code fondé sur les positions, comme row[2], dépend de l’ordre des colonnes. Un objet reader fondé sur les dictionnaires permet de désigner par son nom la valeur nécessaire. Un dictionnaire associe des clés à des valeurs ; ici, l’en-tête fournit les clés et chaque enregistrement de données fournit leurs valeurs.

Lire les champs par leur nom

import csv
with open("inventory.csv", newline="", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    rows = list(reader)

Pour l’en-tête product,stock,price et la ligne notebook,12,2.50, le premier dictionnaire est {'product': 'notebook', 'stock': '12', 'price': '2.50'}. reader.fieldnames donne les noms de l’en-tête. L’en-tête est consommé automatiquement ; appeler next(reader) passerait le premier enregistrement de données.

Utilise row["stock"] pour sélectionner le stock, même si les colonnes changent d’ordre. Convertis-le avec int() pour comparer les quantités. Les valeurs restent des chaînes ; les noms de colonnes ne donnent pas de types numériques à l’objet reader.

Filtrer et calculer un total

Supposons que le tableau contienne un stock de 12 cahiers au prix de 2,50, de 3 stylos à 1,20, de 0 agrafeuse à 7,95 et de 25 chemises à 0,80.

low = [r for r in rows if int(r["stock"]) < 5]
value = sum(int(r["stock"]) * float(r["price"]) for r in rows)

low contient les lignes du stylo et de l’agrafeuse. La valeur est de 53,6 € : les cahiers y contribuent pour 30, les stylos pour 3,6, les agrafeuses pour 0 et les chemises pour 20. Le filtre utilise le stock, tandis que le total utilise à la fois le stock et le prix.

Distinguer les clés manquantes des valeurs manquantes

Les noms de l’en-tête doivent correspondre exactement. Name et name sont des clés différentes. Un espace après une virgule peut faire partie d’un en-tête ; skipinitialspace=True supprime les espaces qui suivent immédiatement les séparateurs.

Un en-tête name,quiz1,quiz2 avec les données Ben,7 produit {'name': 'Ben', 'quiz1': '7', 'quiz2': None}. La clé existe, mais sa valeur manque. int(None) lève TypeError. Un champ présent mais vide vaut "", et sa conversion lève ValueError. Une clé absente de l’en-tête provoque en revanche KeyError lors de l’accès.

Avec les données Cara,1,2,3, les champs en trop sont réunis sous la forme None: ['3'] ; les champs nommés contiennent toujours "Cara", "1" et "2". Vérifie la structure d’une ligne lorsque l’exactitude des totaux dépend de chaque champ.

Écrire certaines colonnes

with open("reorder.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["product", "stock"])
    writer.writeheader()
    for r in low:
        writer.writerow({"product": r["product"], "stock": r["stock"]})

fieldnames fixe l’ordre de sortie, quel que soit l’ordre du dictionnaire. Les clés manquantes du dictionnaire deviennent des champs vides. Par défaut, les clés en trop lèvent ValueError : passer à cet objet writer à deux colonnes un dictionnaire d’inventaire contenant price échoue. Construis le dictionnaire plus petit comme indiqué, ou choisis extrasaction="ignore" lorsque l’omission des champs en trop est volontaire.

Une exception est un objet qui signale un problème pendant l’exécution. La lever interrompt l’exécution normale. Si aucun gestionnaire ne la traite, Python termine le programme avec une trace d’appels, un rapport des appels qui ont conduit à l’erreur.

Commencer par le bas

def average(values):
    return sum(values) / len(values)

def report():
    scores = []
    print(average(scores))

report()

La trace d’appels se termine par ZeroDivisionError: division by zero. Commence par là : le type nomme la nature du problème et le message donne des détails. L’entrée située juste au-dessus pointe vers la division dans average(). Les entrées précédentes montrent l’appel depuis report() et l’appel initial à report(). La liste est vide, donc sa longueur est 0. La ligne signalée comme défaillante est celle où le problème apparaît ; l’affectation précédente de la liste vide explique son origine.

Choisir le type correspondant

int("abc") reçoit un type d’entrée autorisé, une chaîne, mais ne peut pas interpréter cette valeur comme un entier. "5" + 3 mélange en revanche des types incompatibles pour l’addition. Une chaîne contenant des chiffres reste une chaîne.

Les opérations sur les fichiers ont des types plus précis : FileNotFoundError pour un chemin introuvable, PermissionError pour un accès refusé et FileExistsError pour la création d’un fichier existant avec "x". Ouvrir un répertoire comme un fichier ordinaire peut lever IsADirectoryError. Décoder des octets avec un encodage incompatible peut lever UnicodeDecodeError.

Comprendre l’arbre généalogique

Les classes d’exceptions forment une hiérarchie. Un gestionnaire visant une classe parente peut intercepter ses classes enfants :

• OSError est la classe parente des erreurs courantes du système de fichiers, notamment FileNotFoundError et PermissionError.
• LookupError est la classe parente d’IndexError et de KeyError.
• ArithmeticError est la classe parente de ZeroDivisionError.
• UnicodeDecodeError descend de ValueError.

Ces branches descendent de Exception, qui descend de BaseException. KeyboardInterrupt et SystemExit descendent quant à elles directement de BaseException. Cette distinction permet à except Exception de laisser passer l’interruption par l’utilisateur et la sortie du programme.

Distinguer les problèmes de syntaxe, d’exécution et de logique

Des deux-points ou une parenthèse fermante manquants peuvent empêcher Python d’analyser un script. La SyntaxError qui en résulte se produit avant l’exécution du script : un try dans ce même script ne peut donc pas l’intercepter. Une exception d’exécution se produit pendant l’exécution d’un code valide. Une erreur de logique produit une réponse incorrecte sans nécessairement lever d’exception, par exemple lorsqu’un total est divisé par le mauvais nombre d’éléments.

Une instruction try exécute du code susceptible d’échouer et offre une voie de reprise pour certaines exceptions. Le gestionnaire doit correspondre au problème que le programme attend et auquel il sait répondre.

Suivre le déroulement

while True:
    try:
        age = int(input("Age: "))
        break
    except ValueError:
        print("Please enter a whole number, like 34.")
print("Next year you will be", age + 1)

Saisir « twenty » amène int() à lever ValueError. Python ignore le reste du try, y compris break, et exécute le gestionnaire correspondant. La boucle demande ensuite une nouvelle saisie. Saisir « 34 » permet au try de se terminer par break : le programme quitte donc la boucle et affiche « Next year you will be 35 ».

Un gestionnaire ne reprend pas à l’instruction qui a échoué. L’exécution continue après l’instruction try, sauf si le gestionnaire lui-même modifie ce déroulement. Si aucun gestionnaire ne correspond, l’exception poursuit sa propagation.

Traiter différemment les échecs différents

try:
    result = int(a) / int(b)
except ValueError:
    print("Both values must be whole numbers.")
except ZeroDivisionError:
    print("The second value cannot be 0.")

Une conversion invalide et un diviseur nul nécessitent des messages différents. Si la réponse doit être identique, regroupe les types dans un tuple : except (ValueError, ZeroDivisionError):. Les parenthèses fonctionnent dans toutes les versions de Python 3. Python 3.14 permet aussi une liste sans parenthèses lorsqu’il n’y a pas de partie as ; la forme avec tuple reste claire d’une version à l’autre.

Python examine les clauses de haut en bas et exécute la première qui correspond. Place FileNotFoundError avant son type parent OSError si un fichier manquant nécessite une réponse particulière. Inverser leur ordre rend le gestionnaire spécifique inaccessible.

Utiliser le message sans masquer d’autres bugs

try:
    quantity = int(text)
except ValueError as err:
    print("Cannot read quantity:", err)

err est l’objet exception ; l’afficher montre son message. type(err).__name__ donne le nom de sa classe. Python supprime la liaison de err à la fin du gestionnaire : copie donc son message dans une autre variable à l’intérieur du bloc si tu en as besoin plus tard.

Garde le try court. Place les calculs ultérieurs hors du gestionnaire de conversion lorsque leurs échecs nécessiteraient un traitement différent. except Exception: peut masquer des bugs comme une variable non définie. Un except: sans type est encore plus large : il intercepte aussi KeyboardInterrupt et SystemExit.

Tester l’opération plutôt qu’une approximation

Tester text.isdigit() ne vérifie pas tout ce que int() accepte. "-5" et " 34" échouent à ce test, mais sont convertis avec succès ; "²" réussit le test, mais ne se convertit pas avec int(). Essayer la conversion et intercepter ValueError applique les règles propres à la conversion.

Lorsque tu gères des données invalides, effectue une action visible ou consigne le problème. Un except ValueError: pass vide peut laisser le programme continuer avec des résultats manquants et sans aucune trace du problème.

Une instruction try peut séparer l’opération susceptible d’échouer, la gestion de l’erreur, le traitement en cas de réussite et le nettoyage. Une exception peut aussi quitter une fonction et être gérée par son appelant.

Donner son propre bloc au traitement en cas de réussite

try:
    x = 10 / int(text)
except ValueError:
    print("not a number")
except ZeroDivisionError:
    print("zero")
else:
    print("result", x)
finally:
    print("done")

Avec text = "4", le programme affiche « result 2.5 » et « done ». Avec "abc", il affiche « not a number » et « done » ; avec "0", il affiche « zero » et « done ».

else s’exécute lorsque le try se termine normalement sans exception. Il ne s’exécute pas après qu’un gestionnaire a traité une erreur. Il est aussi ignoré lorsque return, break ou continue fait quitter le try prématurément. Les erreurs levées dans else ne sont pas interceptées par les clauses except précédentes de cette instruction : le traitement en cas de réussite ne partage donc pas accidentellement les gestionnaires de l’opération susceptible d’échouer.

Exécuter le nettoyage quelle que soit la sortie

finally s’exécute lorsque le flot d’exécution quitte l’instruction : après une réussite, après une exception gérée et avant qu’une exception non gérée poursuive sa propagation. Il s’exécute aussi avant qu’un retour en attente soit effectué.

def label():
    try:
        return "from try"
    finally:
        print("finally ran")

value = label()
print(value)

Ce code affiche « finally ran » puis « from try ». Le retour attendait pendant l’exécution du nettoyage. Pour les fichiers, with assure déjà la fermeture et évite donc généralement de la programmer manuellement dans finally.

Ne place pas de sortie telle que return, break ou continue dans finally. Quitter ainsi le bloc de nettoyage peut abandonner une exception en attente ou remplacer une valeur de retour. Python 3.14 et les versions ultérieures émettent un SyntaxWarning pour ce schéma. Réserve le bloc au nettoyage.

Suivre une exception jusqu’à l’appelant

def read_scores(path):
    with open(path, encoding="utf-8") as f:
        return [int(line) for line in f]

try:
    scores = read_scores("scores.txt")
except FileNotFoundError:
    print("The score file is missing.")

Si l’ouverture échoue, read_scores() n’a pas de gestionnaire : FileNotFoundError se propage donc jusqu’à l’appel dans le try externe. L’appelant la gère et affiche le message. Si une ligne n’est pas un entier, une ValueError suit le même chemin, mais le gestionnaire de fichier manquant ne lui correspond pas.

Choisir le niveau capable d’apporter une réponse utile

Une fonction de lecture peut savoir comment obtenir des données sans savoir si un fichier manquant doit entraîner une nouvelle tentative, l’abandon d’une tâche ou un arrêt propre. Laisser l’exception atteindre l’appelant qui communique avec l’utilisateur lui laisse ce choix. L’intercepter trop tôt et renvoyer une liste vide peut masquer la différence entre un fichier vide et une lecture échouée.

Un programme connaît un échec maîtrisé lorsqu’il réagit à un problème de manière contrôlée et utile. Il peut demander une nouvelle saisie, signaler une ligne ignorée ou s’arrêter avec un message clair. Choisis cette réponse selon l’usage qui sera fait du résultat.

Réessayer après un fichier manquant

while True:
    name = input("File name: ").strip()
    try:
        with open(name, encoding="utf-8") as f:
            text = f.read()
    except FileNotFoundError:
        print(f"No file named '{name}'. Please try again.")
    else:
        break
print(len(text.splitlines()), "lines")

Une ouverture échouée fait ignorer l’affectation et conduit au gestionnaire. La boucle demande une nouvelle saisie. Une lecture réussie conduit à else, interrompt la boucle et laisse text disponible pour le décompte final. Si le bloc a été ouvert, with ferme le fichier quelle que soit la manière dont il est quitté.

Pour différents problèmes de fichier, utilise FileNotFoundError, puis PermissionError, puis un gestionnaire général OSError si d’autres erreurs du système de fichiers nécessitent une réponse. Les clauses spécifiques doivent venir en premier. Le décodage d’octets invalides est un autre problème ; un message sur un chemin manquant ne le décrirait pas.

Traiter chaque ligne de données séparément

Pour un bilan rapide des ventes, supposons que les lignes CSV après l’en-tête soient coffee,4, tea,two, muffin,3, cookie, et juice,5.

import csv
total = 0
skipped = 0
with open("sales.csv", newline="", encoding="utf-8") as f:
    reader = csv.reader(f)
    next(reader, None)
    for row in reader:
        try:
            if len(row) != 2:
                raise ValueError("expected two fields")
            quantity = int(row[1])
        except ValueError as err:
            skipped += 1
            print(f"sales.csv, ending line {reader.line_num}: {err}")
        else:
            total += quantity
print("Total:", total, "Skipped:", skipped)

Le total des quantités valides est de 12. Le mot « two » et la quantité vide sont rejetés : le nombre de lignes ignorées est donc de 2. La vérification de la ligne transforme aussi un nombre inattendu de champs en erreur de données signalée avant l’accès par indice. Placer try dans la boucle permet de traiter l’enregistrement suivant après un échec ; placer la boucle dans un seul try ferait quitter la boucle au premier échec.

Indiquer précisément les emplacements

Pour les cinq enregistrements d’une seule ligne, les valeurs invalides se terminent aux lignes 3 et 5 du fichier. enumerate(reader, start=2) correspondrait ici à ces numéros de ligne, mais un saut de ligne entre guillemets fait s’étendre un enregistrement CSV sur plusieurs lignes. reader.line_num indique le nombre de lignes physiques consommées par l’objet reader. Préciser qu’il s’agit de la ligne de fin rend les messages exacts pour les enregistrements multilignes.

Décider si un résultat partiel est acceptable

Un comptage exploratoire rapide peut tolérer des lignes ignorées et signalées. Un total financier ou de notes peut nécessiter chaque enregistrement : arrête-toi et demande des données corrigées au lieu de présenter un total partiel comme complet. Indique le fichier, l’emplacement et le problème pour qu’il puisse être corrigé.

Après import sys, sys.exit("Could not open sales.csv") écrit le message sur la sortie d’erreur et quitte le programme avec le code de sortie 1. Cet appel lève SystemExit, que except Exception n’intercepte pas. Utilise des gestionnaires précis pour qu’une erreur de programmation sans rapport ne soit pas présentée à tort comme un problème de fichier.

Une fonction devrait signaler lorsqu’elle ne peut pas produire un résultat valide. raise déclenche une exception à ce stade, afin que le cheminement invalide ne puisse pas continuer comme si l’opération avait réussi.

Vérifier avant de calculer

def withdraw(balance, amount):
    if amount <= 0:
        raise ValueError(f"amount must be positive, got {amount}")
    if amount > balance:
        raise ValueError(f"amount {amount} is more than the balance {balance}")
    return balance - amount

withdraw(100, 30) renvoie 70. withdraw(100, 150) lève une erreur concernant le solde ; withdraw(100, -5) lève une erreur concernant un montant non positif. Aucun de ces appels qui échouent n’atteint la soustraction.

Une exception levée suit les mêmes règles de gestion qu’une erreur native. Si un gestionnaire correspondant dans la fonction l’intercepte, l’exécution peut y continuer. Sinon, l’exception quitte la fonction et atteint l’appelant. Si aucun gestionnaire n’est trouvé, Python affiche une trace d’appels.

Laisser l’appelant choisir la réponse

balance = 100
amount = 150
try:
    balance = withdraw(balance, amount)
except ValueError as err:
    print(f"Cannot withdraw: {err}")

La fonction indique pourquoi elle ne peut pas effectuer le retrait. L’appelant décide d’afficher un message. Comme l’appel de fonction échoue avant de renvoyer une valeur, l’affectation ne remplace pas l’ancien solde par un résultat. Un autre appelant pourrait demander un montant inférieur ou annuler une opération sans modifier la fonction.

Afficher plutôt un avertissement dans la fonction et renvoyer None peut amener l’appelant à utiliser une valeur invalide dans un calcul ultérieur. Lever une exception maintient le lien entre l’échec et sa cause et fournit à l’appelant un chemin distinct pour gérer l’erreur.

Choisir un type parlant

Un montant numérique négatif est une valeur inacceptable. Une liste fournie lorsqu’un nombre est nécessaire est d’un type inadapté. Le type d’exception fait partie du comportement de la fonction : les appelants l’utilisent pour choisir les gestionnaires. Ne choisis pas un type simplement parce qu’il t’est familier.

Écrire un message utile

Un message devrait indiquer ce qui était attendu et ce qui a été reçu. f"age must be between 0 and 130, got {age}" indique comment corriger le problème. Un message tel que « erreur » ne fournit aucun détail utile. Limite le message à l’opération qui a échoué ; le code destiné à l’utilisateur peut ajouter le contexte plus général.

raise ValueError("amount must be positive") crée une exception avec un message. raise ValueError est également valide et en crée une sans message. Une simple chaîne n’est pas une exception : raise "error" lève TypeError, car les objets levés doivent dériver de BaseException.

Parfois, une fonction constate une erreur, mais ne peut pas achever sa gestion. Elle peut devoir laisser la même erreur se propager, la transformer en une erreur plus utile ou donner son propre type d’exception à un problème précis du programme.

Relancer l’erreur courante

def read_text(path):
    try:
        with open(path, encoding="utf-8") as f:
            return f.read()
    except FileNotFoundError:
        print(f"Missing: {path}")
        raise

Le raise seul dans le gestionnaire relance l’exception courante. Afficher seulement un message terminerait le gestionnaire et la fonction renverrait alors None ; relancer l’exception rend l’échec de la lecture visible pour l’appelant. Un raise seul a besoin d’une exception active à relancer.

Transformer l’erreur en préservant sa cause

def read_price(row):
    try:
        text = row["price"]
    except KeyError as err:
        raise ValueError("row has no 'price' column") from err
    return float(text)

Une clé manquante devient une ValueError dont le message concerne la ligne. from err enregistre la KeyError d’origine comme cause directe. La trace d’appels montre l’erreur d’origine, le lien entre les deux et la nouvelle erreur. L’appelant peut gérer le type transformé tout en conservant la cause de bas niveau pour le débogage.

Ce gestionnaire se limite à l’accès par clé. Une valeur présente telle que "free" échoue plus tard à float(text) avec sa propre ValueError ; elle n’est pas signalée à tort comme une colonne manquante.

Définir un type distinct

class InsufficientFundsError(ValueError):
    pass

Ce schéma crée une classe d’exception personnalisée. Par convention, son nom se termine par Error. Le nom entre parenthèses est son type parent : cette classe est donc une sorte de ValueError.

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(
            f"balance {balance}, requested {amount}"
        )
    return balance - amount

try:
    withdraw(100, 150)
except InsufficientFundsError as err:
    print("Not enough money:", err)

Le programme affiche « Not enough money: balance 100, requested 150 ». Un appelant peut distinguer des fonds insuffisants d’une autre valeur invalide. Si un gestionnaire ValueError apparaissait avant ce gestionnaire spécifique, le type parent intercepterait l’exception en premier.

Choisir le type parent selon la gestion voulue

Dériver de ValueError permet à la fois à un gestionnaire spécifique et à un gestionnaire plus général des erreurs de valeur d’intercepter le type personnalisé. Dériver directement de Exception crée une branche distincte d’erreurs ordinaires : except ValueError ne l’intercepterait donc pas. Un type personnalisé est utile lorsque les appelants ont besoin d’une réponse distincte ; un type natif clair et un message suffisent dans le cas contraire.