Lire et écrire des fichiers en Python : texte, CSV et JSON

Faites entrer et sortir vos données — du texte brut avec with open(), des tableaux avec pandas, et des données structurées avec JSON.

Lire et écrire des fichiers en Python : ouvrir des fichiers texte en toute sécurité avec le gestionnaire de contexte with-open, charger et enregistrer du CSV avec pandas read_csv/to_csv (et le module csv de la bibliothèque standard), et manipuler du JSON via json.load/json.dump et pandas read_json/to_json.

Date de publication

26 juin 2026

Modifié

7 juillet 2026

AstucePoints clés
  • Ouvrez toujours vos fichiers avec with open(...). Le gestionnaire de contexte ferme le fichier à votre place — même si une erreur survient en pleine lecture — pour ne jamais laisser fuir un descripteur de fichier ni perdre un fichier à moitié écrit.
  • Pour les tableaux, tournez-vous vers pandas. pd.read_csv(path) charge un CSV dans un DataFrame ; df.to_csv(path, index=False) le réécrit. Le module csv de la bibliothèque standard est là quand vous voulez des lignes sans pandas.
  • JSON propose deux paires de fonctions. json.load/json.dump travaillent sur des fichiers ; json.loads/json.dumps (notez le s, pour string) travaillent sur des chaînes. pandas ajoute read_json/to_json pour le JSON tabulaire.
  • Construisez vos chemins avec pathlib.Path, pas par concaténation de chaînes. Path("data") / "results.csv" est sûr quel que soit le système, lisible, et vous offre gratuitement .exists(), .parent et compagnie.
  • Définissez encoding="utf-8" quand vous écrivez du texte. C’est le choix portable par défaut, et il vous épargne le UnicodeDecodeError dès que vos données contiennent un accent, un emoji ou un caractère non latin.
  • to_csv écrit l’index par défaut. Passez index=False à moins que cette colonne supplémentaire en tête ne soit quelque chose que vous voulez vraiment.

Introduction

Presque toute analyse commence de la même façon — on lit des données — et se termine de la même façon — on écrit les résultats. Entre ces deux étapes se trouve le travail pour lequel vous êtes venu, mais si vous ne pouvez pas charger un fichier ou enregistrer ce que vous avez produit de manière fiable, rien d’autre n’a d’importance. Cette leçon est la boîte à outils pour faire entrer et sortir vos données.

Nous couvrirons les trois formats que vous rencontrerez sans cesse : le texte brut (lu et écrit avec le gestionnaire de contexte with open()), le CSV (le format de tableau universel, géré par pandas) et le JSON (le format universel de données structurées, géré par le module json). Au passage, nous utiliserons pathlib.Path pour des chemins de fichiers propres et définirons l’encodage utf-8 pour que votre texte survive aux accents et aux emoji.

Une remarque pratique sur le code ci-dessous : pour qu’il s’exécute partout et ne laisse aucune trace, chaque exemple écrit dans un répertoire temporaire (via le module tempfile de Python) et le relit aussitôt. Sur votre propre machine, vous utiliseriez simplement un vrai chemin comme "results.csv".

Chaque résultat ici est réel — et vous pouvez l’exécuter vous-même sans rien installer : cliquez sur Try ▸ sous n’importe quel bloc pour l’exécuter en direct dans votre navigateur (Python démarre au premier Run, puis c’est instantané).

Fichiers texte avec with open()

L’opération de fichier la plus élémentaire est la lecture et l’écriture de texte brut. La bonne façon de le faire — la seule façon que vous devriez employer — est avec le gestionnaire de contexte with open(...). open() renvoie un objet fichier ; l’envelopper dans with garantit que le fichier est fermé automatiquement à la fin du bloc, qu’il se termine normalement ou qu’il lève une erreur en cours de route.

Ici, nous écrivons quelques lignes de texte, puis les relisons. Nous utilisons tempfile pour obtenir un répertoire jetable afin que cela ne laisse aucun fichier dans votre projet :

import tempfile
from pathlib import Path

# A temporary directory + a file path inside it (nothing lands in your repo)
tmpdir = Path(tempfile.mkdtemp())
notes_path = tmpdir / "notes.txt"

# Write mode "w" — creates the file (or overwrites it). utf-8 keeps accents safe.
with open(notes_path, "w", encoding="utf-8") as f:
    f.write("First line\n")
    f.write("Second line — with an accent: café\n")

print("Wrote:", notes_path)
Wrote: /var/folders/xm/8p6yj4bj6s57n4v_51714lwm0000gp/T/tmpf_6cuhly/notes.txt

Le drapeau "w" signifie write (écriture) : il crée le fichier ou tronque un fichier existant. Nous passons encoding="utf-8" explicitement — nous verrons pourquoi plus bas. Chaque appel à write() ajoute le texte exactement tel quel, donc nous incluons nous-mêmes les sauts de ligne \n. Dès que le bloc with se termine, le fichier est vidé sur le disque et fermé ; nous n’appelons jamais f.close().

Maintenant, relisons-le. "r" est le mode read (lecture, par défaut), et .read() charge tout le fichier dans une seule chaîne :

with open(notes_path, "r", encoding="utf-8") as f:
    content = f.read()

print(content)
First line
Second line — with an accent: café

Le café accentué a survécu à l’aller-retour parce que les deux extrémités étaient d’accord sur utf-8. Quand vous voulez les lignes sous forme de liste plutôt que d’une seule grande chaîne, parcourez le fichier — il livre une ligne à la fois, ce qui est économe en mémoire pour les gros fichiers :

with open(notes_path, "r", encoding="utf-8") as f:
    lines = [line.rstrip("\n") for line in f]

print(lines)
['First line', 'Second line — with an accent: café']

Parcourir l’objet fichier le lit paresseusement, ligne par ligne, donc cela fonctionne pareillement sur un fichier de deux lignes ou de deux gigaoctets. rstrip("\n") retire le saut de ligne final que porte chaque ligne.

Pourquoi with est important

Sans with, vous écririez f = open(path); ... ; f.close() — et si quoi que ce soit entre ces lignes levait une erreur, f.close() serait sauté et le descripteur fuirait. Le gestionnaire de contexte ferme le fichier quoi qu’il arrive, c’est pourquoi chaque exemple ici l’utilise et vous devriez en faire autant. Pour ajouter à la fin au lieu d’écraser, ouvrez avec "a" :

with open(notes_path, "a", encoding="utf-8") as f:
    f.write("Third line, appended\n")

with open(notes_path, "r", encoding="utf-8") as f:
    print(f.read())
First line
Second line — with an accent: café
Third line, appended

"a" (append, ajout) ajoute à la fin du fichier existant plutôt que de le tronquer — utile pour les journaux.

CSV avec pandas

Pour les données tabulaires — tout ce qui ressemble à un tableur — pandas est l’outil du quotidien. read_csv analyse un fichier CSV pour en faire un DataFrame, et to_csv réécrit un DataFrame. Construisons un petit DataFrame, enregistrons-le et rechargeons-le.

import pandas as pd

df = pd.DataFrame({
    "name": ["Ada", "Linus", "Grace"],
    "lang": ["Python", "C", "COBOL"],
    "score": [95, 88, 91],
})

csv_path = tmpdir / "people.csv"
df.to_csv(csv_path, index=False)   # index=False — don't write the row numbers as a column

print("Saved CSV to:", csv_path)
Saved CSV to: /var/folders/xm/8p6yj4bj6s57n4v_51714lwm0000gp/T/tmpf_6cuhly/people.csv

L’argument clé est index=False. Par défaut, pandas écrit l’index du DataFrame (les étiquettes de ligne 0, 1, 2) comme une colonne supplémentaire sans nom. Neuf fois sur dix, vous n’en voulez pas dans votre fichier, donc index=False la supprime. Maintenant, relisons-le :

loaded = pd.read_csv(csv_path)
print(loaded)
print()
print("dtypes:")
print(loaded.dtypes)
    name    lang  score
0    Ada  Python     95
1  Linus       C     88
2  Grace   COBOL     91

dtypes:
name     object
lang     object
score     int64
dtype: object

read_csv renvoie un DataFrame et déduit les types des colonnes à votre place — name et lang reviennent en texte (object), score en entier. Cette déduction de type est l’essentiel de la raison pour laquelle on utilise pandas pour les CSV plutôt que de les analyser à la main. read_csv propose des dizaines d’options pour le monde réel et ses désordres — sep=";" pour les fichiers séparés par des points-virgules, na_values=[...] pour des marqueurs de valeurs manquantes personnalisés, parse_dates=[...] pour les colonnes de dates — mais pour un fichier propre, la ligne unique suffit.

Une note sur le module csv de la bibliothèque standard

Vous n’avez pas besoin de pandas pour gérer du CSV. La bibliothèque standard de Python fournit un module csv qui lit et écrit les lignes sous forme de simples listes ou dictionnaires Python — pratique quand vous voulez zéro dépendance, que vous traitez ligne par ligne en flux, ou que vous ne voulez pas d’un DataFrame entier en mémoire. Voici les mêmes données avec csv.writer et csv.reader :

import csv

csv2_path = tmpdir / "people_stdlib.csv"

# Write: newline="" is required on the open() call to avoid blank rows on some platforms
with open(csv2_path, "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["name", "lang", "score"])   # header row
    writer.writerow(["Ada", "Python", 95])
    writer.writerow(["Linus", "C", 88])

# Read: each row comes back as a list of strings
with open(csv2_path, "r", newline="", encoding="utf-8") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)
['name', 'lang', 'score']
['Ada', 'Python', '95']
['Linus', 'C', '88']

Deux choses à remarquer. Vous ouvrez le fichier avec newline="" — c’est la façon documentée de laisser le module csv gérer lui-même les fins de ligne (sautez-la et vous pouvez obtenir des lignes vides sous Windows). Et chaque valeur revient sous forme de chaîne — csv ne fait aucune déduction de type, donc "95" reste du texte tant que vous ne le convertissez pas. C’est exactement la corvée que pandas fait pour vous, ce qui explique pourquoi pandas l’emporte pour l’analyse tandis que le module csv de la bibliothèque standard brille pour les scripts légers et sans dépendance. (csv.DictReader/DictWriter fonctionnent de la même façon mais avec les noms de colonnes comme clés de dictionnaire.)

JSON — données structurées

JSON est la langue universelle des API, des fichiers de configuration et des données imbriquées qui ne tiennent pas dans un tableau plat. Le module json de Python le fait correspondre proprement à des objets Python : un objet JSON devient un dict, un tableau devient une list, et les chaînes/nombres/booléens/null deviennent str/int/float/bool/None.

Le module vous offre deux paires de fonctions, et il vaut la peine de bien cerner la différence une bonne fois pour toutes :

  • json.dump / json.load travaillent sur des fichiers (vous passez un objet fichier).
  • json.dumps / json.loads travaillent sur des chaînes — le s final est pour string.

Fichiers JSON : json.dump et json.load

Partez d’un objet Python imbriqué — un dictionnaire contenant une liste de dictionnaires — et écrivez-le dans un fichier :

import json

config = {
    "project": "datanovia",
    "version": 2,
    "tags": ["python", "csv", "json"],
    "authors": [
        {"name": "Ada", "role": "lead"},
        {"name": "Grace", "role": "review"},
    ],
}

json_path = tmpdir / "config.json"
with open(json_path, "w", encoding="utf-8") as f:
    json.dump(config, f, indent=2, ensure_ascii=False)

# Show what actually landed on disk
print(json_path.read_text(encoding="utf-8"))
{
  "project": "datanovia",
  "version": 2,
  "tags": [
    "python",
    "csv",
    "json"
  ],
  "authors": [
    {
      "name": "Ada",
      "role": "lead"
    },
    {
      "name": "Grace",
      "role": "review"
    }
  ]
}

json.dump(obj, file) sérialise l’objet directement dans le fichier ouvert. indent=2 le met en forme pour qu’il soit lisible par un humain (omettez-le et vous obtenez une seule ligne compacte). ensure_ascii=False conserve les caractères non ASCII tels quels au lieu de les échapper en \uXXXX — associez-le à l’encodage utf-8 et le texte accentué ou non latin reste lisible dans le fichier. La relecture reconstitue l’objet Python exact :

with open(json_path, "r", encoding="utf-8") as f:
    restored = json.load(f)

print(type(restored))
print(restored["authors"][0]["name"])
<class 'dict'>
Ada

json.load(file) analyse le fichier et vous rend le dict — liste imbriquée, dictionnaires imbriqués et tout le reste — si bien que restored["authors"][0]["name"] plonge directement dans la structure.

Chaînes JSON : json.dumps et json.loads

Quand le JSON n’est pas un fichier mais une chaîne — un corps de réponse d’API, une valeur dans une colonne de base de données, une ligne dans un journal — utilisez les versions avec s. Elles convertissent entre un objet Python et une chaîne au format JSON en mémoire, sans aucun fichier :

# Object -> JSON string
text = json.dumps({"name": "Ada", "score": 95})
print(text)
print(type(text))

# JSON string -> object
back = json.loads('{"name": "Ada", "score": 95}')
print(back["score"], "-", type(back))
{"name": "Ada", "score": 95}
<class 'str'>
95 - <class 'dict'>

json.dumps(obj) renvoie une str ; json.loads(s) analyse une str pour en refaire un objet Python. Mêmes données, mêmes règles — la seule différence avec dump/load est fichiers contre chaînes.

JSON tabulaire avec pandas

Quand votre JSON est en réalité un tableau — une liste d’enregistrements ayant les mêmes clés — pandas le lit et l’écrit directement avec read_json et to_json, exactement comme le CSV :

records_path = tmpdir / "people.json"

# Write the DataFrame as JSON; orient="records" gives one JSON object per row
df.to_json(records_path, orient="records", indent=2)
print(records_path.read_text(encoding="utf-8"))
[
  {
    "name":"Ada",
    "lang":"Python",
    "score":95
  },
  {
    "name":"Linus",
    "lang":"C",
    "score":88
  },
  {
    "name":"Grace",
    "lang":"COBOL",
    "score":91
  }
]

orient="records" produit la forme la plus courante et la plus portable : un tableau JSON où chaque élément est une ligne sous forme d’objet. Relisez-le directement dans un DataFrame :

from_json = pd.read_json(records_path, orient="records")
print(from_json)
    name    lang  score
0    Ada  Python     95
1  Linus       C     88
2  Grace   COBOL     91

read_json renvoie un DataFrame, types déduits, prêt pour les mêmes sélections, filtrages et regroupements que vous feriez après read_csv. Utilisez le module json pour des structures imbriquées arbitraires ; utilisez read_json/to_json de pandas quand les données sont véritablement rectangulaires.

Chemins de fichiers avec pathlib

Vous avez vu pathlib.Path tout au long de cette leçon — voici le pourquoi rassemblé en un seul endroit. Path est la manière moderne et indépendante du système d’exploitation de construire et d’inspecter des chemins. Vous assemblez les parties avec l’opérateur / (qui se lit mieux que la concaténation de chaînes et utilise automatiquement le bon séparateur sous Windows ou macOS/Linux), et vous obtenez gratuitement une foule d’aides utiles :

from pathlib import Path

p = tmpdir / "people.csv"

print("name      :", p.name)        # file name with extension
print("stem      :", p.stem)        # file name without extension
print("suffix    :", p.suffix)      # the extension
print("parent    :", p.parent)      # the containing directory
print("exists    :", p.exists())    # does it exist on disk?
name      : people.csv
stem      : people
suffix    : .csv
parent    : /var/folders/xm/8p6yj4bj6s57n4v_51714lwm0000gp/T/tmpf_6cuhly
exists    : True

Assembler avec / construit le chemin ; .name, .stem, .suffix et .parent le décortiquent ; .exists() interroge le système de fichiers. Les objets Path offrent aussi des raccourcis que vous avez déjà vus — p.read_text(encoding="utf-8") et p.write_text(...) sont les équivalents en une ligne d’un bloc with open() pour les petits fichiers. Préférez Path aux chaînes "folder/" + name bricolées à la main : c’est plus sûr entre systèmes d’exploitation et bien plus facile à lire.

Un mot sur l’encodage

Vous avez peut-être remarqué encoding="utf-8" sur presque chaque appel de texte et de JSON. Voici la règle : précisez-le toujours quand vous écrivez du texte, et vous ne rencontrerez que rarement un bug d’encodage. UTF-8 est la norme universelle — il peut représenter chaque caractère (accents, emoji, tous les alphabets) et c’est ce qu’attend le reste du monde. L’encodage par défaut de Python dépend de la locale de votre système d’exploitation, si bien qu’un fichier écrit sans encodage explicite sur une machine peut échouer à la lecture sur une autre avec une UnicodeDecodeError. Fixez-le à utf-8 aux deux extrémités et toute cette catégorie de problèmes disparaît. (Les read_csv/to_csv et read_json/to_json de pandas utilisent déjà UTF-8 par défaut, ce qui est une raison de plus pour lesquelles ils sont agréables à utiliser.)

🟢 Avec un agent IA

Apportez un fichier CSV ou JSON désordonné et demandez à Prova : « lis ceci dans pandas et remodèle-le comme j’en ai besoin » — elle choisit les bonnes options read_csv/read_json et écrit la transformation. Parce que le runtime est juste là, vous l’exécutez et vérifiez le nombre de lignes/enregistrements avant et après avec df.shape (et les types de colonnes avec df.dtypes), pour repérer une ligne supprimée ou dupliquée au lieu de prendre une réponse plausible pour argent comptant. The runtime is the judge. Demandez à Prova →

Essayez en direct

Les blocs ci-dessus ont été exécutés au moment de la génération. Modifiez celui-ci et appuyez sur Run pour essayer les E/S de fichiers par vous-même — il s’exécute dans votre navigateur via Pyodide (sans installation). Il écrit dans un répertoire temporaire jetable et le relit aussitôt, donc rien n’atterrit sur le disque. Ou cliquez sur Try ▸ sous n’importe quel bloc ci-dessus pour y déposer son code.

Problèmes courants

Oublier de fermer un fichier — la raison de toujours utiliser with. Si vous écrivez f = open(path, "w"); f.write(...) sans jamais appeler f.close() (ou en plantant avant), vos données peuvent rester en tampon sans être vidées et ne jamais atteindre le disque, et vous laissez fuir un descripteur de fichier. with open(...) as f: ferme le fichier automatiquement à la fin du bloc — même en cas d’exception — donc les données sont vidées et le descripteur libéré à chaque fois. Il n’y a aucun inconvénient ; utilisez-le toujours.

FileNotFoundError à partir d’un chemin relatif. open("data.csv") cherche le fichier relativement au répertoire de travail courant, qui n’est pas nécessairement là où réside votre script — exécutez le même script depuis un autre dossier et il casse. Construisez plutôt un chemin absolu à partir d’un ancrage connu : Path(__file__).parent / "data.csv" se résout relativement au fichier du script, pas à l’endroit d’où vous l’avez lancé. Et vérifiez path.exists() avant d’ouvrir si un fichier manquant est une possibilité réelle.

to_csv a écrit une colonne d’index parasite sans nom. Par défaut, df.to_csv(path) écrit l’index du DataFrame comme une colonne supplémentaire en tête, qui réapparaît ensuite sous forme de colonne Unnamed: 0 quand vous relisez le fichier. Passez index=False (df.to_csv(path, index=False)) chaque fois que l’index de ligne n’est pas une donnée significative — c’est-à-dire la plupart du temps.

TypeError: Object of type ... is not JSON serializable. json.dump/dumps ne connaissent que les types JSON de base (dict, list, str, int, float, bool, None). Donnez-lui un entier NumPy, un Timestamp pandas, un datetime ou un set et il lève cette erreur. Convertissez d’abord — int(np_value), dt.isoformat() pour les dates, list(my_set) — ou passez default=str à json.dumps comme solution fourre-tout qui transforme en chaîne tout ce qui est inconnu.

Questions fréquentes

Le plus simple est pandas : import pandas as pd; df = pd.read_csv("data.csv") charge le fichier dans un DataFrame et déduit le type de chaque colonne à votre place. Pour en réécrire un, df.to_csv("out.csv", index=False) — le index=False supprime la colonne des numéros de ligne. Si vous préférez ne pas dépendre de pandas, le module csv de la bibliothèque standard lit les lignes en listes (csv.reader) ou en dictionnaires (csv.DictReader), mais il ne fait aucune conversion de type, donc chaque valeur revient sous forme de chaîne.

Utilisez json.dump, qui sérialise un objet Python directement dans un fichier ouvert :

import json
with open("config.json", "w", encoding="utf-8") as f:
    json.dump(my_dict, f, indent=2, ensure_ascii=False)

indent=2 le met en forme et ensure_ascii=False garde les accents et les caractères non latins lisibles. Pour transformer un objet en chaîne JSON plutôt qu’en fichier, utilisez json.dumps (avec le s). Pour relire du JSON, json.load(file) pour un fichier ou json.loads(string) pour une chaîne.

with open(path) as f: ouvre le fichier et le lie à f, puis garantit que le fichier est fermé à la fin du bloc indenté — même si une erreur est levée à l’intérieur. C’est le motif du gestionnaire de contexte : il remplace le f = open(...); ...; f.close() manuel et supprime le risque de laisser fuir un descripteur de fichier ou de perdre des données non vidées quand quelque chose tourne mal. Ouvrez toujours vos fichiers de cette façon ; il n’y a aucune raison de ne pas le faire.

Le s final signifie string (chaîne). json.load(file) lit depuis un objet fichier et json.dump(obj, file) y écrit. json.loads(s) analyse une chaîne pour en faire un objet Python et json.dumps(obj) transforme un objet en chaîne. Utilisez la paire fichier quand vous lisez/écrivez un fichier .json sur le disque ; utilisez la paire chaîne pour du JSON qui arrive sous forme de texte — un corps de réponse d’API, une valeur de base de données, une ligne de journal.

Parce que l’encodage texte par défaut de Python dépend de la locale du système d’exploitation, un fichier écrit sans encodage explicite peut échouer à la lecture sur une autre machine avec une UnicodeDecodeError dès l’instant où il contient un accent, un emoji ou un caractère non latin. UTF-8 est la norme universelle qui représente chaque caractère, donc fixer encoding="utf-8" à la fois à l’écriture et à la lecture rend vos fichiers portables et fait disparaître toute cette catégorie de bugs.

Testez vos connaissances

Travaillez chaque tâche dans la cellule Essayez en direct ci-dessus — modifiez et exécutez.

Utilisez tempfile pour que rien n’atterrisse dans votre projet : import tempfile; from pathlib import Path; tmpdir = Path(tempfile.mkdtemp()).

Tâche 1. Écrivez les trois lignes "alpha", "beta", "gamma" (une par ligne) dans un fichier texte avec with open(...), puis relisez le fichier et affichez le nombre de lignes qu’il contient.

Ouvrez en mode "w" et f.write(line + "\n") pour chaque ligne. Pour compter les lignes à la lecture, parcourez le fichier (ou lisez tout et splitlines()) puis prenez len(...).

import tempfile
from pathlib import Path

tmpdir = Path(tempfile.mkdtemp())
path = tmpdir / "words.txt"

with open(path, "w", encoding="utf-8") as f:
    for word in ["alpha", "beta", "gamma"]:
        f.write(word + "\n")

with open(path, "r", encoding="utf-8") as f:
    lines = f.read().splitlines()

print(len(lines), "lines:", lines)
3 lines: ['alpha', 'beta', 'gamma']

Le fichier compte 3 lignes. Parcourir ou splitlines() vous donnent tous deux une liste propre sans sauts de ligne en fin de ligne.

Tâche 2. Construisez un petit DataFrame avec les colonnes city et pop, enregistrez-le en CSV sans la colonne d’index, relisez-le et confirmez qu’il n’y a aucune colonne parasite sans nom.

L’argument clé sur to_csv est index=False. Après read_csv, vérifiez df.columns — vous ne devriez voir que city et pop.

import pandas as pd
import tempfile
from pathlib import Path

tmpdir = Path(tempfile.mkdtemp())
path = tmpdir / "cities.csv"

df = pd.DataFrame({"city": ["Oslo", "Lyon", "Accra"], "pop": [700, 515, 2300]})
df.to_csv(path, index=False)

loaded = pd.read_csv(path)
print(loaded)
print("columns:", list(loaded.columns))
    city   pop
0   Oslo   700
1   Lyon   515
2  Accra  2300
columns: ['city', 'pop']

Parce que nous avons passé index=False, les colonnes sont exactement ["city", "pop"] — pas de Unnamed: 0. Retirez le index=False et vous verriez cette colonne d’index supplémentaire réapparaître à la lecture.

Vérification rapide. Vous avez une chaîne au format JSON provenant d’une API — '{"id": 7, "ok": true}' — et vous la voulez sous forme de dictionnaire Python. Quelle fonction appelez-vous, json.load ou json.loads ?

json.loads (avec le s, pour string). json.load lit depuis un objet fichier, donc lui passer une chaîne lève une erreur. Utilisez json.loads('{"id": 7, "ok": true}') pour analyser une chaîne en mémoire ; réservez json.load(f) à un fichier ouvert.

Conclusion

Vous pouvez désormais faire entrer et sortir vos données de Python en toute confiance : du texte brut via le gestionnaire de contexte with open(), des tableaux via les read_csv/to_csv de pandas (ou le module csv de la bibliothèque standard quand vous voulez zéro dépendance), et des données structurées via json.load/dump pour les fichiers et json.loads/dumps pour les chaînes, avec les read_json/to_json de pandas pour le JSON tabulaire. Construisez vos chemins avec pathlib.Path et fixez encoding="utf-8", et les bugs quotidiens de manipulation de fichiers cessent tout simplement de se produire.

À lire aussi : Les DataFrames pandas — travaillez avec les données une fois chargées · Lire des fichiers CSV et texte en R — les mêmes lecture/écriture en R.

Réutilisation

Citation

BibTeX
@online{2026,
  author = {},
  title = {Lire et écrire des fichiers en Python : texte, CSV et JSON},
  date = {2026-06-26},
  url = {https://www.datanovia.com/learn/programming/python-foundations/read-write-files-json},
  langid = {fr}
}
Veuillez citer ce travail comme suit :
“Lire et écrire des fichiers en Python : texte, CSV et JSON.” 2026. June 26. https://www.datanovia.com/learn/programming/python-foundations/read-write-files-json.