Python JSON : lire, écrire et parser du JSON avec le module json

JSON et Python parlent les mêmes formes

JSON est le format par défaut pour les API, les fichiers de config et l'échange de données sur le web. Heureusement pour les programmeurs Python, un objet JSON correspond directement à un dict Python, un tableau JSON à une liste, une chaîne JSON à une str. Cet alignement étroit est pourquoi lire et écrire du JSON en Python est une opération de deux lignes.

Le module json de la bibliothèque standard gère les deux directions.

Parser une chaîne JSON

json.loads(text) — « load string » — prend une chaîne au format JSON et renvoie l'objet Python qu'elle représente :

Le résultat est un simple dict. Tu accèdes à ses clés comme à n'importe quel dict — pas de wrapper JSON spécial, pas de méthode .parse() sur le résultat.

Si la chaîne n'est pas du JSON valide, json.loads lève json.JSONDecodeError. Le message d'erreur inclut la ligne et la colonne du problème, ce qui suffit généralement pour repérer une virgule manquante ou un guillemet non échappé.

Écrire du JSON comme une chaîne

json.dumps(data) — « dump string » — fait l'inverse : prend un objet Python et renvoie une chaîne JSON :

True, False et None de Python sont traduits automatiquement en true, false et null de JSON. Les nombres et les chaînes passent sans changement. Les listes deviennent des arrays, les dicts deviennent des objects.

Pretty printing

La sortie par défaut de json.dumps est compacte — bien pour le transport réseau, dur pour les humains. Passe indent=2 pour quelque chose de plus lisible :

Quelques autres options de dumps à connaître :

• sort_keys=True — trie les clés d'objet par ordre alphabétique. Utile pour une sortie déterministe (fichiers de config, fixtures de tests, diffs).
• ensure_ascii=False — écrit les caractères non ASCII (é, ü, 中) tels quels au lieu d'échappements \u. Généralement le bon choix pour les fichiers UTF-8.
• separators=(",", ":") — la sortie la plus serrée possible. Combiné avec ensure_ascii=False, ça donne le JSON UTF-8 le plus compact qu'on puisse produire.

Lire du JSON depuis un fichier

json.load(file) — sans s — lit directement depuis un objet fichier. Le motif courant l'associe à with open :

import json

with open("config.json") as f:
    config = json.load(f)

print(config["version"])

Pas besoin de lire tout le fichier dans une chaîne d'abord ; json.load streame à travers l'objet fichier.

Écrire du JSON dans un fichier

json.dump(data, file) est le contrepartie pour l'écriture de fichier :

import json

data = {"created": "2026-01-01", "items": [1, 2, 3]}

with open("state.json", "w") as f:
    json.dump(data, f, indent=2)

L'option indent fonctionne ici aussi. Ouvre le fichier résultant et tu verras un document JSON joliment formaté.

Lire une réponse d'API JSON

La plupart des bibliothèques HTTP te donnent des bytes ou du texte ; tu appelles json.loads pour les transformer en données utilisables :

import json
import urllib.request

with urllib.request.urlopen("https://api.example.com/users/1") as response:
    text = response.read().decode("utf-8")

user = json.loads(text)
print(user["name"])

La bibliothèque requests (couverte séparément) saute une étape — elle a une méthode .json() sur la réponse qui appelle json.loads pour toi.

Ce que JSON peut et ne peut pas représenter

Le système de types de JSON est plus étroit que celui de Python. La correspondance dans les deux directions :

Python	JSON
dict	object
list, tuple	array
str	string
int, float	number
True	true
False	false
None	null

Les tuples reviennent en listes — le caractère tuple est perdu. Les sets, classes personnalisées et objets datetime ne peuvent pas être sérialisés par défaut ; tu obtiens TypeError: Object of type X is not JSON serializable.

Gérer datetime et objets personnalisés

Deux approches courantes.

Convertis en structure JSON-safe d'abord. Fais la transformation dans ton propre code, puis sérialise un simple dict :

Passe une fonction default=. json.dumps l'appelle pour chaque valeur qu'il ne sait pas sérialiser :

Quand tu relis les données, tu dois convertir ces chaînes ISO en datetime toi-même — JSON ne se souvient pas de ce qu'elles étaient à l'origine.

Aller-retour d'un dict à travers JSON

Un test rapide que les dicts survivent :

Les valeurs sont égales, mais ce sont des objets différents. C'est souvent ce que tu veux — json.dumps + json.loads est un moyen peu coûteux de faire une copie profonde de toute structure compatible JSON.

Un exemple réaliste

Un petit script qui charge une config JSON, met à jour un champ et la sauvegarde :

import json
from pathlib import Path

config_path = Path("settings.json")

# Charger (avec un défaut si le fichier n'existe pas).
if config_path.exists():
    config = json.loads(config_path.read_text())
else:
    config = {"theme": "dark", "last_opened": None}

# Mettre à jour.
config["last_opened"] = "2026-01-15"

# Sauvegarder, pretty-printed.
config_path.write_text(json.dumps(config, indent=2, ensure_ascii=False))

C'est un cycle complet « lire, modifier, écrire » du JSON en une douzaine de lignes.

Quelques habitudes

• Utilise with open(...) pour les fichiers, toujours. JSON, c'est juste du texte ; toutes les règles de gestion de fichier s'appliquent.
• Préfère indent=2 pour les fichiers que les humains lisent — config, fixtures, données exportées. Saute-le pour le trafic réseau où la compacité compte.
• Mets ensure_ascii=False pour une sortie UTF-8 pour que les noms avec accents ou caractères non latins restent lisibles.
• Valide avec try/except json.JSONDecodeError quand tu parses des données que tu n'as pas produites.

Ensuite

JSON gère les données clé-valeur. Le prochain outil du même chapitre est CSV — le support intégré de Python pour le format tabulaire derrière la plupart des exports de tableur que tu rencontreras.