JSON Formatter Python — Guide json.dumps()

Maria Santos·Backend Developer·Révisé parDmitri Volkov·Publié 2026-03-10

Utilisez le Formateur et Embellisseur JSON gratuit directement dans votre navigateur — sans installation.

Essayer Formateur et Embellisseur JSON en ligne →

Quand je débogue un client API Python, le premier réflexe est python afficher json lisible — un seul appel à json.dumps(data, indent=4) et un blob illisible en une seule ligne devient instantanément navigable. Le module intégré json de Python gère cela entièrement dans la bibliothèque standard — aucune installation tierce requise. Si vous avez juste besoin d'un résultat rapide sans écrire de code, le Formateur JSON de ToolDeck le fait instantanément. Ce guide couvre chaque méthode pratique : json.dumps() avec tous ses paramètres, pprint, orjson pour le formatage haute performance, la CLI json.tool, et des scénarios réels comme le formatage des réponses d'API et la lecture depuis le disque — le tout avec du code compatible Python 3.8+. Il couvre également la sérialisation de types personnalisés comme datetime et UUID, le streaming de fichiers de plusieurs gigaoctets avec ijson, et la coloration syntaxique dans le terminal avec rich.

Points Clés

→json.dumps(data, indent=4) est intégré dans la stdlib de Python depuis la version 2.6 — aucune installation requise.
→Passez ensure_ascii=False dès que vos données contiennent des lettres accentuées, des caractères CJK ou des emojis.
→Pour datetime, UUID ou des classes personnalisées, utilisez le paramètre default= ou créez une sous-classe de json.JSONEncoder.
→separators=(',', ':') supprime tous les espaces — à utiliser pour la transmission réseau ou l'intégration dans les URL.
→orjson est 5–10× plus rapide que la stdlib et gère nativement datetime et uuid.UUID.
→pprint.pprint() produit de la syntaxe Python (True/None), pas du JSON valide — ne jamais utiliser pour des fichiers ou des réponses d'API.
→Pour les fichiers JSON de plus de 50 Mo, streamez avec ijson plutôt que json.load() pour éviter MemoryError.

Qu'est-ce que l'affichage JSON lisible ?

L'affichage lisible (pretty printing) transforme une chaîne JSON dense et minifiée en un format lisible par l'humain avec une indentation cohérente et des sauts de ligne. La transformation est purement cosmétique : les données sont identiques, seule la présentation change. Le module json de Python gère cela entièrement dans la bibliothèque standard — rien à installer.

Before · json

After · json

{"id":"usr_9f3a2b","name":"Pierre Dubois","roles":["admin","editor"],"prefs":{"theme":"dark","lang":"fr"}}

{
    "id": "usr_9f3a2b",
    "name": "Pierre Dubois",
    "roles": [
        "admin",
        "editor"
    ],
    "prefs": {
        "theme": "dark",
        "lang": "fr"
    }
}

json.dumps() — La méthode standard pour formater du JSON

json.dumps() fait partie de la bibliothèque standard de Python depuis Python 2.6 — simplement import json, aucune installation requise. Il sérialise tout objet Python compatible JSON en une chaîne formatée. Le paramètre clé est indent : mettez-le à 4 (ou 2) pour obtenir une sortie lisible.

Python 3.8+ — exemple minimal

import json

utilisateur = {
    "id": "usr_9f3a2b",
    "name": "Pierre Dubois",
    "roles": ["admin", "editor"],
    "prefs": {"theme": "dark", "lang": "fr"}
}

print(json.dumps(utilisateur, indent=4, ensure_ascii=False))
# Sortie :
# {
#     "id": "usr_9f3a2b",
#     "name": "Pierre Dubois",
#     "roles": [
#         "admin",
#         "editor"
#     ],
#     "prefs": {
#         "theme": "dark",
#         "lang": "fr"
#     }
# }

En production, vous voudrez souvent sort_keys=True (sortie cohérente entre les exécutions) et ensure_ascii=False (conserver les caractères non-ASCII lisibles) :

Python 3.8+ — avec sort_keys et ensure_ascii

import json

reponse_api = {
    "timestamp": "2024-05-01T10:30:00Z",
    "status": "success",
    "data": {
        "user_id": "usr_9f3a2b",
        "display_name": "Marie Laurent",
        "ville": "Paris",
        "score": 4892.5,
        "tags": ["python", "backend", "api"]
    }
}

print(json.dumps(reponse_api, indent=4, sort_keys=True, ensure_ascii=False))
# Sortie (clés triées, accents préservés) :
# {
#     "data": {
#         "display_name": "Marie Laurent",
#         "score": 4892.5,
#         "tags": ["api", "backend", "python"],
#         "user_id": "usr_9f3a2b",
#         "ville": "Paris"
#     },
#     "status": "success",
#     "timestamp": "2024-05-01T10:30:00Z"
# }

Remarque :json.dumps() retourne une chaîne. Pour écrire du JSON formaté directement dans un fichier, utilisez json.dump(data, f, indent=4) (sans le s) — il écrit dans un objet fichier et évite de créer une chaîne intermédiaire en mémoire.

Référence des paramètres de json.dumps()

Tous les paramètres sont optionnels sauf l'objet lui-même. Les valeurs par défaut produisent du JSON compact et sûr en ASCII — passez les paramètres explicitement pour une sortie lisible par l'humain.

Paramètre

Type

Défaut

Description

obj

any

—

Objet Python à sérialiser en chaîne au format JSON.

indent

int | str | None

None

Espaces par niveau d'indentation. None = ligne unique compacte, 0 = sauts de ligne uniquement, 4 = standard.

sort_keys

bool

False

Trier les clés du dictionnaire alphabétiquement sur tous les niveaux imbriqués.

ensure_ascii

bool

True

Échapper les caractères non-ASCII en \uXXXX. Mettre False pour conserver les caractères Unicode tels quels.

separators

tuple | None

None

Paire (sep_élément, sep_clé). Utiliser (",", ":") pour la sortie la plus compacte sans espaces.

default

callable | None

None

Appelé pour les types non sérialisables par défaut. Lever TypeError pour rejeter la valeur.

allow_nan

bool

True

Sérialiser float("nan") et float("inf") comme littéraux JS. Mettre False pour lever ValueError.

Sortie JSON compacte avec le paramètre separators

Par défaut, json.dumps() sépare les éléments avec ", " et les clés des valeurs avec ": ". Le paramètre separators remplace les deux. Passer (',', ':') supprime tous les espaces pour produire le JSON valide le plus compact possible — utile pour la transmission réseau, l'intégration dans les URL, ou le stockage de JSON dans une colonne de base de données où chaque octet compte.

Python 3.8+

import json

payload = {
    "endpoint": "/api/v2/events",
    "filters": {"status": "active", "limit": 100},
    "sort": "desc"
}

# Par défaut — espaces après les séparateurs (lisible)
sortie_normale = json.dumps(payload)
# {"endpoint": "/api/v2/events", "filters": {"status": "active", "limit": 100}, "sort": "desc"}
# len = 88

# Compact — sans espace du tout
sortie_compacte = json.dumps(payload, separators=(',', ':'))
# {"endpoint":"/api/v2/events","filters":{"status":"active","limit":100},"sort":"desc"}
# len = 80  (9% plus petit ; économies plus grandes sur des payloads plus larges et profondément imbriqués)

# Compact + clés triées pour des clés de cache reproductibles ou des hachages de contenu
canonique = json.dumps(payload, separators=(',', ':'), sort_keys=True)
print(canonique)
# {"endpoint":"/api/v2/events","filters":{"limit":100,"status":"active"},"sort":"desc"}

Remarque :Quand vous passez indent= avec separators=, l'argument separators contrôle uniquement les séparateurs inline — les sauts de ligne et l'indentation de indent sont préservés. Pour une sortie compacte sur une seule ligne, omettez indent (ou passez None) et définissez separators=(',', ':').

Sérialisation d'objets Python personnalisés avec le paramètre default

Le module standard json sérialise les dicts, listes, chaînes, nombres, booléens et None — mais lève un TypeError pour tout autre type. Les deux coupables les plus courants en code de production sont les objets datetime et les UUID.

Python 3.8+ — TypeError sans gestion personnalisée

import json
from datetime import datetime, timezone
import uuid

commande = {
    "order_id": uuid.uuid4(),            # ❌ TypeError: UUID is not JSON serializable
    "placed_at": datetime.now(timezone.utc),  # ❌ TypeError: datetime is not JSON serializable
    "total_eur": 142.50,
    "items": ["pro-subscription", "addon-storage"]
}

json.dumps(commande)  # lève TypeError

Approche 1 — le paramètre default=

Passez un callable à default=. json.dumps()l'appelle pour tout objet qu'il ne peut pas gérer. Retournez une représentation sérialisable, ou levez TypeError pour les types que vous ne supportez pas explicitement — ne jamais ignorer silencieusement les types inconnus.

Python 3.8+

import json
from datetime import datetime, timezone, date
import uuid
from decimal import Decimal

def json_default(obj):
    if isinstance(obj, (datetime, date)):
        return obj.isoformat()
    if isinstance(obj, uuid.UUID):
        return str(obj)
    if isinstance(obj, Decimal):
        return float(obj)
    raise TypeError(f"Type {type(obj).__name__!r} is not JSON serializable")

commande = {
    "order_id": uuid.uuid4(),
    "placed_at": datetime(2024, 5, 1, 10, 30, 0, tzinfo=timezone.utc),
    "total_eur": Decimal("142.50"),
    "items": ["pro-subscription", "addon-storage"]
}

print(json.dumps(commande, indent=4, default=json_default))
# {
#     "order_id": "a3f1c2d4-e5b6-7890-abcd-ef1234567890",
#     "placed_at": "2024-05-01T10:30:00+00:00",
#     "total_eur": 142.5,
#     "items": ["pro-subscription", "addon-storage"]
# }

Approche 2 — sous-classe de json.JSONEncoder

Pour une logique d'encodage réutilisable partagée entre plusieurs modules, créer une sous-classe de json.JSONEncoder est plus propre que de passer une fonction default partout. Redéfinissez la méthode default et appelez super().default(obj) comme dernier recours — cela préserve le comportement d'erreur correct pour les types non supportés.

Python 3.8+

import json
from datetime import datetime, timezone
import uuid
from decimal import Decimal

class AppEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        if isinstance(obj, uuid.UUID):
            return str(obj)
        if isinstance(obj, Decimal):
            return float(obj)
        return super().default(obj)  # lève TypeError pour les types inconnus

commande = {
    "order_id": uuid.uuid4(),
    "placed_at": datetime(2024, 5, 1, 10, 30, 0, tzinfo=timezone.utc),
    "total_eur": Decimal("142.50"),
}

# Passez la classe encoder via cls=
print(json.dumps(commande, indent=4, cls=AppEncoder))
# Sortie identique à l'approche default=

Remarque :Appelez toujours super().default(obj) (ou levez TypeError explicitement) pour les types non reconnus. Retourner silencieusement str(obj) pour tout corrompra des objets qui auraient dû lever une erreur — un bug difficile à tracer en production.

Décodage inverse — object_hook

L'encodage n'est que la moitié de l'histoire. Pour reconstruire un objet Python personnalisé à partir du JSON, passez une fonction object_hook à json.loads() ou json.load(). Le hook est appelé pour chaque objet JSON décodé (dict) et peut retourner n'importe quelle valeur Python — vous donnant un aller-retour encode ↔ decode complet.

Python 3.8+

import json
from datetime import datetime
from dataclasses import dataclass

@dataclass
class Event:
    name: str
    occurred_at: datetime
    user_id: str

def encode_event(obj):
    if isinstance(obj, Event):
        return {
            "__type__": "Event",
            "name": obj.name,
            "occurred_at": obj.occurred_at.isoformat(),
            "user_id": obj.user_id,
        }
    raise TypeError(f"Cannot serialize {type(obj)}")

def decode_event(d):
    if d.get("__type__") == "Event":
        return Event(
            name=d["name"],
            occurred_at=datetime.fromisoformat(d["occurred_at"]),
            user_id=d["user_id"],
        )
    return d

# Encoder
event = Event("login", datetime(2024, 5, 1, 10, 30), "usr_9f3a2b")
json_str = json.dumps(event, default=encode_event, indent=4)

# Décoder en instance Event
restored = json.loads(json_str, object_hook=decode_event)
print(type(restored))           # <class 'Event'>
print(restored.occurred_at)     # 2024-05-01 10:30:00

Remarque :Le object_hook est appelé pour chaque dict imbriqué dans le document — pas seulement au niveau supérieur. Incluez un champ discriminateur (comme "__type__") pour que le hook puisse distinguer vos objets personnalisés des dicts simples qui doivent rester tels quels.

pprint — Le module alternatif (et quand ne pas l'utiliser)

Le module pprint de Python (pretty printer) formate les structures de données Python pour la lisibilité dans le terminal. Il fonctionne sur des objets Python parsés, pas sur des chaînes JSON — et sa sortie utilise la syntaxe Python, pas la syntaxe JSON.

Python 3.8+

import json, pprint

raw = '{"sensor_id":"s-441","readings":[23.1,23.4,22.9],"unit":"celsius","active":true}'
data = json.loads(raw)

# pprint — repr Python valide, PAS du JSON valide
pprint.pprint(data, sort_dicts=False)
# {'sensor_id': 's-441',
#  'readings': [23.1, 23.4, 22.9],
#  'unit': 'celsius',
#  'active': True}        ← Python True, pas JSON true

# json.dumps — JSON valide
print(json.dumps(data, indent=4))
# {
#     "sensor_id": "s-441",
#     "readings": [23.1, 23.4, 22.9],
#     "unit": "celsius",
#     "active": true      ← JSON valide
# }

Attention :N'envoyez jamais la sortie de pprintà un endpoint d'API ou ne l'écrivez pas dans un fichier .json — cela cassera tout parseur JSON attendant une syntaxe standard. Utilisez json.dumps(indent=4) pour toute sortie qui doit être du JSON valide.

Quand pprint a du sens : inspection rapide dans un REPL ou un log de débogage, surtout quand l'objet contient des types non sérialisables en JSON (sets, instances de classes personnalisées, dataclasses avant conversion).

Comment afficher lisiblement une réponse JSON de Requests

Le scénario réel le plus courant : vous avez un fichier JSON sur le disque ou une réponse HTTP d'une API, et vous voulez le formater pour le débogage ou la journalisation. Les deux cas utilisent la même approche — parser en dict Python, puis formater avec json.dumps().

Lecture depuis un fichier

Python 3.8+

import json

try:
    with open("config.json", "r", encoding="utf-8") as f:
        data = json.load(f)

    # Afficher dans la console
    print(json.dumps(data, indent=4, ensure_ascii=False))

    # Ou écrire la version formatée sur le disque
    with open("config.formate.json", "w", encoding="utf-8") as f:
        json.dump(data, f, indent=4, ensure_ascii=False)

except json.JSONDecodeError as e:
    print(f"JSON invalide : {e}")
except FileNotFoundError:
    print(f"Fichier introuvable : config.json")

Formatage d'une réponse d'API

Python 3.8+ (requiert : pip install requests)

import json, requests
from requests.exceptions import HTTPError, ConnectionError, Timeout

def afficher_api(url: str) -> None:
    try:
        resp = requests.get(url, timeout=10)
        resp.raise_for_status()
        print(json.dumps(resp.json(), indent=4, ensure_ascii=False))
    except HTTPError as e:
        print(f"HTTP {e.response.status_code} : {e}")
    except (ConnectionError, Timeout) as e:
        print(f"Erreur réseau : {e}")
    except json.JSONDecodeError:
        print(f"Le corps de la réponse n'est pas du JSON :\n{resp.text[:500]}")

afficher_api("https://api.github.com/repos/python/cpython")

Remarque :response.json()parse déjà le corps de la réponse — pas besoin d'appeler json.loads() séparément. Ajoutez toujours raise_for_status() avant d'accéder à .json()pour intercepter les erreurs 4xx/5xx avant qu'elles causent une erreur de parsing confuse.

Formatage en ligne de commande

Python est livré avec json.tool, un module CLI pour formater du JSON directement depuis le terminal — aucun script Python requis. Disponible sur toute machine avec Python installé.

bash

# Formater un fichier local
python -m json.tool config.json

# Passer une réponse d'API dans le formateur
curl -s https://api.github.com/users/gvanrossum | python -m json.tool

# Formater depuis stdin
echo '{"service":"api-gateway","version":"2.1.0","healthy":true}' | python -m json.tool

# Trier les clés alphabétiquement
python -m json.tool --sort-keys data.json

# Indentation personnalisée (Python 3.9+)
python -m json.tool --indent 2 data.json

Remarque :Python 3.9 a ajouté les options --indent et --no-indent. Pour un filtrage JSON plus puissant dans le terminal, envisagez jq — mais python -m json.tool couvre le formatage sans dépendances supplémentaires.

Si vous n'êtes pas du tout dans un terminal — en collant une réponse Postman ou un fichier de log — le Formateur JSON de ToolDeck vous permet de coller, formater et copier en une seule étape avec coloration syntaxique et validation intégrées.

Bibliothèques alternatives : orjson et rich

orjson — 5–10× plus rapide avec support natif des types

Le module standard json est suffisamment rapide pour la plupart des cas, mais si vous sérialisez des milliers d'objets par seconde — pipelines de logging, APIs à haut débit, grandes exportations de données — orjson est 5–10× plus rapide. Il gère aussi nativement des types que la bibliothèque standard ne peut pas sérialiser sans une fonction default personnalisée : datetime, uuid.UUID, tableaux numpy et dataclasses.

bash — installation

pip install orjson

Python 3.8+

import orjson
from datetime import datetime, timezone
import uuid

event = {
    "event_id": uuid.uuid4(),                  # pas de str() nécessaire — orjson gère UUID
    "timestamp": datetime.now(timezone.utc),   # pas d'isoformat() nécessaire
    "service": "auth-service",
    "level": "INFO",
    "payload": {
        "user_id": "usr_9f3a2b",
        "action": "login",
        "ip": "192.168.1.42",
        "latency_ms": 34
    }
}

# orjson.dumps retourne des bytes ; .decode() convertit en str
print(orjson.dumps(event, option=orjson.OPT_INDENT_2).decode())
# {
#   "event_id": "a3f1c2d4-e5b6-7890-abcd-ef1234567890",
#   "timestamp": "2024-05-01T10:30:00+00:00",
#   "service": "auth-service",
#   ...
# }

Deux choses à savoir : orjson.dumps() retourne des bytes, pas une chaîne — appelez .decode() si vous avez besoin d'une chaîne. Il ne supporte que l'indentation à 2 espaces via OPT_INDENT_2 ; pour une sortie à 4 espaces, utilisez le standard json.dumps(indent=4).

rich — Coloration syntaxique dans le terminal

Si vous inspectez régulièrement du JSON dans un terminal ou un REPL, rich affiche une sortie colorée avec coloration syntaxique qui rend les structures profondément imbriquées lisibles en un coup d'œil. Clés, chaînes, nombres et booléens ont chacun une couleur distincte — beaucoup plus facile à analyser qu'un mur de texte monochrome. C'est un outil de débogage uniquement, pas pour la sérialisation en production.

bash — installation

pip install rich

Python 3.8+

from rich import print_json
import json

# print_json() accepte une chaîne JSON
raw = '{"event":"login","user_id":"usr_9f3a2b","timestamp":"2024-05-01T10:30:00Z","success":true,"meta":{"ip":"192.168.1.42","attempts":1}}'
print_json(raw)

# Pour afficher un dict Python, convertissez d'abord en chaîne
data = {
    "status": "success",
    "count": 42,
    "tags": ["python", "api", "backend"]
}
print_json(json.dumps(data))

Attention :rich.print_json()émet des codes d'échappement ANSI pour la couleur du terminal — ne capturez jamais cette sortie pour l'écrire dans un fichier .jsonou l'envoyer comme réponse d'API. Utilisez json.dumps(indent=4) pour toute sortie lisible par machine.

simplejson — Remplacement compatible avec la stdlib

simplejson est la bibliothèque qui est devenue le module standard json de Python — elle est toujours maintenue indépendamment et prend de l'avance sur la stdlib pour les fonctionnalités mineures. C'est un vrai remplacement drop-in : changez l'import et le reste du code est inchangé. Utile quand vous avez besoin du support Decimal sans encodeur personnalisé, ou quand vous ciblez des environnements Python plus anciens.

bash — installation

pip install simplejson

Python 3.8+

import simplejson as json  # API identique à la stdlib
from decimal import Decimal

commande = {
    "item": "Abonnement API Lyon",
    "price": Decimal("49.99"),   # la stdlib json lèverait TypeError ici
    "quantity": 3,
}

# simplejson sérialise Decimal nativement — pas de default= nécessaire
print(json.dumps(commande, indent=4, use_decimal=True))
# {
#     "item": "Abonnement API Lyon",
#     "price": 49.99,
#     "quantity": 3
# }

Remarque :Pour les performances pures, orjson est le meilleur choix. Optez pour simplejson quand vous avez besoin de la sérialisation native de Decimalsans écrire un encodeur personnalisé, ou pour maintenir une base de code qui l'utilise déjà.

Traitement de fichiers JSON volumineux sans manquer de mémoire

json.load() lit l'intégralité du fichier en mémoire avant de pouvoir accéder à un seul champ. Sur un fichier avec des millions d'enregistrements ou un payload de plus d'un gigaoctet, cela cause un MemoryError — ou au mieux force le processus à utiliser le swap et à ralentir considérablement.

Streaming avec ijson

ijsonest un parseur JSON en streaming qui génère des éléments un par un depuis un objet fichier. Vous itérez sur les éléments d'un tableau sans jamais charger l'ensemble du dataset en mémoire — la mémoire de pointe reste proportionnelle à un seul objet, pas à la taille du fichier.

bash — installation

pip install ijson

Python 3.8+

import ijson
from decimal import Decimal

# events.json structure : {"events": [...millions d'objets...]}
revenu_total = Decimal("0")
compteur_connexions = 0

with open("events.json", "rb") as f:   # ijson requiert le mode binaire
    for event in ijson.items(f, "events.item"):
        if event.get("type") == "purchase":
            revenu_total += Decimal(str(event["amount_eur"]))
        elif event.get("type") == "login":
            compteur_connexions += 1

print(f"Revenu : {revenu_total:.2f} EUR  |  Connexions : {compteur_connexions}")
# Traite un fichier de 2 Go avec ~30 Mo de mémoire de pointe

Remarque :Passez de json.load() à ijson quand votre fichier dépasse environ 50–100 Mo. En dessous de ce seuil, json.load()est plus simple et significativement plus rapide car il utilise un parseur en extension C en interne. Au-dessus de 100 Mo, les économies de mémoire du streaming l'emportent sur la surcharge.

NDJSON — un objet JSON par ligne

NDJSON (Newline Delimited JSON, aussi appelé JSON Lines ou .jsonl) stocke un objet JSON complet par ligne. Les exportateurs de logs, consommateurs Kafka et pipelines de données produisent fréquemment ce format car chaque ligne peut être ajoutée et lue indépendamment. La bibliothèque standard le gère sans dépendances supplémentaires.

Python 3.8+

import json
from pathlib import Path

# Écrire en NDJSON — un événement par ligne
events = [
    {"ts": "2024-05-01T10:00:00Z", "user": "usr_9f3a2b", "action": "login"},
    {"ts": "2024-05-01T10:01:03Z", "user": "usr_9f3a2b", "action": "purchase", "sku": "pro-plan"},
    {"ts": "2024-05-01T10:15:42Z", "user": "usr_4ab1d9", "action": "login"},
]

with open("events.ndjson", "w", encoding="utf-8") as f:
    for event in events:
        f.write(json.dumps(event, ensure_ascii=False) + "\n")

# Lire en NDJSON — mémoire constante, quelle que soit la taille du fichier
compteur_achats = 0
with open("events.ndjson", "r", encoding="utf-8") as f:
    for ligne in f:
        ligne = ligne.strip()
        if not ligne:           # ignorer les lignes vides
            continue
        event = json.loads(ligne)
        if event.get("action") == "purchase":
            compteur_achats += 1
            print(f"{event['ts']} — {event['user']} a acheté {event['sku']}")

Erreurs Courantes

J'ai vu ces quatre erreurs dans presque chaque revue de code impliquant la sérialisation JSON — surtout chez les développeurs venant de JavaScript où JSON.stringifygère l'encodage automatiquement.

❌ Utiliser print(data) au lieu de json.dumps()

Problème : print() sur un dict utilise le repr Python — la sortie affiche True/None (syntaxe Python), pas true/null (syntaxe JSON). Ce n'est pas du JSON valide.

Solution : Utilisez toujours json.dumps(data, indent=4) pour une sortie JSON valide et lisible.

Before · Python

After · Python

data = {"active": True, "count": None}
print(data)
# {'active': True, 'count': None}

print(json.dumps(data, indent=4))
# {
#     "active": true,
#     "count": null
# }

❌ Oublier ensure_ascii=False avec du texte non-ASCII

Problème : Les caractères spéciaux (lettres accentuées, CJK, emojis) sont échappés en séquences \\uXXXX, rendant la sortie illisible.

Solution : Passez ensure_ascii=False pour conserver les caractères Unicode originaux.

Before · Python

After · Python

user = {"name": "Marie Laurent", "ville": "Montréal"}
json.dumps(user, indent=2)
# {"name": "Marie Laurent", "ville": "Montr\u00e9al"}

json.dumps(user, indent=2, ensure_ascii=False)
# {"name": "Marie Laurent", "ville": "Montréal"}

❌ Utiliser json.dumps() pour écrire dans un fichier

Problème : json.dumps() retourne une chaîne ; vous avez ensuite besoin d'un appel f.write() séparé, créant une chaîne intermédiaire inutile.

Solution : Utilisez json.dump(data, f, indent=4) — il écrit directement dans l'objet fichier.

Before · Python

After · Python

with open("out.json", "w") as f:
    f.write(json.dumps(data, indent=4))

with open("out.json", "w", encoding="utf-8") as f:
    json.dump(data, f, indent=4, ensure_ascii=False)

❌ Formater avec pprint en attendant du JSON valide

Problème : pprint.pprint() utilise la syntaxe Python (True, None, guillemets simples) que les parseurs JSON rejettent.

Solution : Utilisez json.dumps(indent=4) pour toute sortie qui doit être parseable comme JSON.

Before · Python

After · Python

import pprint
pprint.pprint({"running": True, "last_error": None})
# {'running': True, 'last_error': None}

import json
print(json.dumps({"running": True, "last_error": None}, indent=4))
# {"running": true, "last_error": null}

Comparaison des méthodes — json.dumps, orjson, simplejson, rich

Utilisez json.dumps() pour le formatage quotidien et l'écriture de fichiers — il couvre 95% des cas sans dépendances. Recourez à orjson lors de la sérialisation dans un chemin critique ou quand vos objets incluent des champs datetime et UUID. Utilisez simplejson quand vous avez besoin d'une compatibilité drop-in avec la stdlib et d'un support Decimal prêt à l'emploi. Réservez rich.print_json() et pprint strictement à l'inspection locale dans le terminal — aucun ne produit de sortie lisible par machine.

Méthode

Sortie

JSON valide

Vitesse

Non-ASCII

Types personnalisés

Installation

json.dumps(indent=4)

Chaîne

✅

Standard

ensure_ascii=False

default= / JSONEncoder

Intégré

json.dump(f, indent=4)

Fichier

✅

Standard

ensure_ascii=False

default= / JSONEncoder

Intégré

pprint.pprint()

repr Python

❌

Standard

Natif

✅ (tout repr)

Intégré

orjson.dumps(OPT_INDENT_2)

Octets

✅

5–10× plus rapide

Natif

datetime, UUID, numpy

pip install orjson

python -m json.tool

stdout CLI

✅

Standard

✅

❌

Intégré

simplejson.dumps()

Chaîne

✅

~1.5× plus rapide

ensure_ascii=False

Decimal nativement

pip install simplejson

rich.print_json()

Terminal seul

✅ (entrée)

Standard

✅

❌

pip install rich

Questions Fréquentes

Comment afficher du JSON de façon lisible en Python ?

Appelez json.dumps(data, indent=4). Le paramètre indent définit le nombre d'espaces par niveau d'imbrication. Importez d'abord le module json — il est inclus dans la bibliothèque standard de Python, aucun pip install n'est nécessaire. Passez ensure_ascii=False si vos données contiennent des lettres accentuées, des caractères CJK ou des emojis.

python

import json

utilisateur = {"username": "pdubois", "plan": "enterprise", "permissions": ["lecture", "écriture", "déploiement"]}
print(json.dumps(utilisateur, indent=4, ensure_ascii=False))

Quelle est la différence entre json.dumps() et json.dump() ?

json.dumps() (avec un "s") retourne une chaîne formatée en mémoire. json.dump() (sans "s") écrit directement dans un objet fichier — passez le handle du fichier ouvert comme second argument. Pour écrire du JSON formaté sur disque, json.dump(data, f, indent=4) est idiomatique et évite de créer une chaîne intermédiaire.

python

# dumps → chaîne en mémoire
formate = json.dumps(data, indent=4)

# dump → écriture directe dans le fichier
with open('sortie.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, indent=4)

Pourquoi json.dumps() affiche \u00e9\u00e0\u00f4 au lieu des caractères réels ?

Par défaut ensure_ascii=True échappe chaque caractère non-ASCII en séquence \uXXXX. Mettez ensure_ascii=False pour conserver les caractères Unicode originaux. C'est particulièrement important pour les noms, adresses et tout contenu généré par les utilisateurs en français ou autres langues non-latines.

python

data = {"ville": "Montréal", "boisson": "café", "mot": "naïf"}

# Par défaut — échappé
json.dumps(data, indent=4)
# {"ville": "Montr\u00e9al", "boisson": "caf\u00e9", ...}

# Lisible
json.dumps(data, indent=4, ensure_ascii=False)
# {"ville": "Montréal", "boisson": "café", "mot": "naïf"}

Comment formater une chaîne JSON (pas un dict) ?

D'abord parser la chaîne avec json.loads(), puis formater avec json.dumps(). Les deux appels peuvent être enchaînés en une ligne pour une inspection rapide dans le terminal.

python

import json

raw = '{"endpoint":"/api/v2/utilisateurs","timeout":30,"reessayer":true}'
print(json.dumps(json.loads(raw), indent=4))

Puis-je utiliser pprint pour formater du JSON en Python ?

pprint.pprint() produit une représentation d'objets Python, pas du JSON valide. Il utilise True/False/None (syntaxe Python) au lieu de true/false/null (syntaxe JSON). Ne jamais passer la sortie de pprint à une API ou un parseur JSON — utilisez json.dumps(indent=4) pour tout ce qui doit être du JSON valide.

python

import pprint, json

data = {"actif": True, "score": None}

pprint.pprint(data)     # {'actif': True, 'score': None}  ← pas du JSON
json.dumps(data, indent=4)  # {"actif": true, "score": null}  ← JSON valide

Comment trier les clés JSON alphabétiquement en Python ?

Ajoutez sort_keys=True à json.dumps(). En ligne de commande, utilisez python -m json.tool --sort-keys data.json. Les clés triées rendent les diffs JSON lisibles et facilitent la détection des valeurs modifiées.

python

import json

serveur = {"workers": 4, "host": "0.0.0.0", "port": 8080, "debug": False}
print(json.dumps(serveur, indent=4, sort_keys=True))
# {
#     "debug": false,
#     "host": "0.0.0.0",
#     "port": 8080,
#     "workers": 4
# }

Python vous donne un contrôle total — sérialiseurs personnalisés, streaming, intégration pipeline. Quand vous avez juste besoin d'inspecter ou partager un extrait formaté, le Formateur JSON de ToolDeck est le chemin le plus rapide : collez votre JSON et obtenez un résultat indenté et coloré sans aucune configuration d'environnement.

Outils Connexes

Formateur JSON

Formatez n'importe quel JSON instantanément dans le navigateur — sans environnement Python. Collez, formatez et copiez en un clic.

Validateur JSON

Validez votre structure JSON avant de le formater — détecte les erreurs de syntaxe qui feraient lever un JSONDecodeError par json.loads().

Diff JSON

Comparez deux réponses JSON côte à côte pour repérer ce qui a changé entre les versions d'API ou les déploiements de configuration.

Décodeur JWT

Décodez et inspectez les tokens JWT retournés par votre API — utile avec le formatage JSON lors du débogage des flux d'authentification.

YAML vers JSON

Convertissez des fichiers de configuration YAML en JSON — utile quand vous devez afficher une réponse d'API au format YAML en JSON.

Aussi disponible en :Go JavaScript Bash

Maria SantosBackend Developer

Maria is a backend developer specialising in Python and API integration. She has broad experience with data pipelines, serialisation formats, and building reliable server-side services. She is an active member of the Python community and enjoys writing practical, example-driven guides that help developers solve real problems without unnecessary theory.

Dmitri VolkovRéviseur technique

Dmitri is a DevOps engineer who relies on Python as his primary scripting and automation language. He builds internal tooling, CI/CD pipelines, and infrastructure automation scripts that run in production across distributed teams. He writes about the Python standard library, subprocess management, file processing, encoding utilities, and the practical shell-adjacent Python that DevOps engineers use every day.