Qu'est-ce que JSON en Python ?

Définition de JSON en Python

JSON, acronyme de JavaScript Object Notation, est un format d'échange de données léger et lisible par l'humain. En Python, le module intégré json permet de sérialiser (convertir des objets Python en chaînes JSON) et de désérialiser (convertir des chaînes JSON en objets Python) des données avec une simplicité remarquable.

Si vous souhaitez maîtriser Python dans son ensemble, y compris la manipulation de données JSON, nous vous recommandons de suivre notre formation complète sur Python qui couvre ce sujet en profondeur.

Le format JSON est devenu un standard incontournable dans le développement web moderne. Il est utilisé pour les API REST, les fichiers de configuration, le stockage de données et bien plus encore. Python, grâce à son module natif json, offre une intégration transparente avec ce format.

Les types de données JSON et leur correspondance Python

Avant de plonger dans les exemples, il est essentiel de comprendre comment les types JSON sont mappés vers les types Python et inversement. Cette correspondance est automatique lorsque vous utilisez le module json.

Les fonctions principales du module json

Le module json propose quatre fonctions principales que vous utiliserez au quotidien. Elles se répartissent en deux paires : l'une pour travailler avec des chaînes de caractères, l'autre pour travailler directement avec des fichiers.

Exemples pratiques

Sérialiser un objet Python en JSON (dumps)

La fonction json.dumps() convertit un objet Python en une chaîne JSON. C'est l'opération la plus courante lorsque vous devez envoyer des données à une API ou les stocker sous forme de texte.

import json

# Création d'un dictionnaire Python
utilisateur = {
    "nom": "Alice Dupont",
    "age": 30,
    "email": "alice@example.com",
    "langages": ["Python", "JavaScript", "Rust"],
    "actif": True,
    "adresse": {
        "ville": "Paris",
        "code_postal": "75001"
    }
}

# Conversion en chaîne JSON
json_string = json.dumps(utilisateur)
print(json_string)
# {"nom": "Alice Dupont", "age": 30, "email": "alice@example.com", ...}

# Avec une mise en forme lisible (indentation)
json_formate = json.dumps(utilisateur, indent=4, ensure_ascii=False)
print(json_formate)

Le paramètre indent=4 ajoute une indentation de 4 espaces pour rendre le JSON lisible. Le paramètre ensure_ascii=False permet de conserver les caractères spéciaux comme les accents au lieu de les encoder en séquences d'échappement Unicode.

Désérialiser une chaîne JSON en objet Python (loads)

La fonction json.loads() effectue l'opération inverse : elle transforme une chaîne JSON en un objet Python natif.

import json

# Chaîne JSON reçue (par exemple d'une API)
json_data = '''
{
    "produit": "Ordinateur portable",
    "prix": 999.99,
    "en_stock": true,
    "caracteristiques": ["16 Go RAM", "512 Go SSD", "Écran 15 pouces"],
    "promotion": null
}
'''

# Conversion en dictionnaire Python
produit = json.loads(json_data)

print(type(produit))        # 
print(produit["produit"])    # Ordinateur portable
print(produit["prix"])       # 999.99
print(produit["en_stock"])   # True (booléen Python)
print(produit["promotion"])  # None (et non "null")

# Accès aux éléments de la liste
for carac in produit["caracteristiques"]:
    print(f"- {carac}")

Remarquez comment true en JSON est automatiquement converti en True en Python, et null devient None. Cette conversion est entièrement transparente.

Lire et écrire des fichiers JSON

Dans la majorité des cas réels, vous travaillerez avec des fichiers JSON plutôt qu'avec des chaînes de caractères. Les fonctions json.dump() et json.load() sont conçues pour cela.

import json

# === ÉCRITURE dans un fichier JSON ===
config = {
    "application": "MonApp",
    "version": "2.1.0",
    "debug": False,
    "base_de_donnees": {
        "hote": "localhost",
        "port": 5432,
        "nom": "ma_base"
    },
    "langues_supportees": ["fr", "en", "es"]
}

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

print("Fichier config.json créé avec succès !")

# === LECTURE depuis un fichier JSON ===
with open("config.json", "r", encoding="utf-8") as fichier:
    config_lue = json.load(fichier)

print(config_lue["application"])  # MonApp
print(config_lue["base_de_donnees"]["port"])  # 5432

Gérer les erreurs de parsing JSON

Lorsque vous traitez des données JSON provenant de sources externes (API, fichiers utilisateur, etc.), il est impératif de gérer les erreurs potentielles. Le module json lève une exception json.JSONDecodeError si le JSON est mal formé.

import json

# JSON invalide (virgule en trop)
json_invalide = '{"nom": "Alice", "age": 30,}'

try:
    data = json.loads(json_invalide)
except json.JSONDecodeError as e:
    print(f"Erreur de parsing JSON : {e}")
    print(f"Position de l'erreur : ligne {e.lineno}, colonne {e.colno}")

# Gestion d'un fichier JSON manquant ou corrompu
try:
    with open("donnees.json", "r", encoding="utf-8") as f:
        data = json.load(f)
except FileNotFoundError:
    print("Le fichier n'existe pas")
    data = {}  # Valeur par défaut
except json.JSONDecodeError as e:
    print(f"Le fichier contient du JSON invalide : {e}")
    data = {}

Sérialiser des objets personnalisés

Par défaut, le module json ne sait pas sérialiser les objets de vos classes personnalisées. Vous devez lui fournir un encodeur personnalisé ou une fonction de conversion.

import json
from datetime import datetime, date


# Méthode 1 : Utiliser le paramètre 'default'
def convertisseur_personnalise(obj):
    """Convertit les objets non sérialisables en types compatibles JSON."""
    if isinstance(obj, (datetime, date)):
        return obj.isoformat()
    if isinstance(obj, set):
        return list(obj)
    raise TypeError(f"Objet de type {type(obj)} non sérialisable")

evenement = {
    "titre": "Conférence Python",
    "date": datetime(2025, 6, 15, 14, 30),
    "tags": {"python", "développement", "conférence"}
}

json_resultat = json.dumps(
    evenement,
    default=convertisseur_personnalise,
    indent=2,
    ensure_ascii=False
)
print(json_resultat)


# Méthode 2 : Créer un JSONEncoder personnalisé
class MonEncodeur(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        if isinstance(obj, set):
            return sorted(list(obj))
        return super().default(obj)

json_resultat2 = json.dumps(evenement, cls=MonEncodeur, indent=2, ensure_ascii=False)
print(json_resultat2)

Les deux méthodes sont valides. Le paramètre default est plus simple pour des cas ponctuels, tandis que la création d'un JSONEncoder personnalisé est préférable lorsque vous avez une logique de sérialisation réutilisable dans tout votre projet.

Paramètres avancés de dumps

La fonction json.dumps() offre de nombreux paramètres pour contrôler finement la sortie JSON.

import json

data = {
    "nom": "Alice",
    "scores": [95, 87, 92],
    "adresse": {"ville": "Lyon", "pays": "France"}
}

# Trier les clés par ordre alphabétique
print(json.dumps(data, sort_keys=True, indent=2))

# Personnaliser les séparateurs pour un JSON compact
print(json.dumps(data, separators=(',', ':')))
# {"nom":"Alice","scores":[95,87,92],"adresse":{"ville":"Lyon","pays":"France"}}

# Combinaison de paramètres pour une sortie optimale
json_optimise = json.dumps(
    data,
    indent=2,
    ensure_ascii=False,
    sort_keys=True,
    separators=(',', ': ')
)
print(json_optimise)

Le paramètre separators permet de contrôler l'espacement dans le JSON généré. En utilisant (',', ':') sans espaces, vous produisez un JSON compact idéal pour le transfert réseau, où chaque octet compte.

Utiliser json avec des données complexes et imbriquées

En pratique, vous rencontrerez souvent des structures JSON complexes avec plusieurs niveaux d'imbrication. Voici comment les manipuler efficacement.

import json

# Réponse typique d'une API
reponse_api = '''
{
    "statut": "succes",
    "total": 2,
    "utilisateurs": [
        {
            "id": 1,
            "nom": "Alice Dupont",
            "competences": ["Python", "Django"],
            "projets": [
                {"nom": "API REST", "terminé": true},
                {"nom": "Bot Discord", "terminé": false}
            ]
        },
        {
            "id": 2,
            "nom": "Bob Martin",
            "competences": ["Python", "Flask"],
            "projets": [
                {"nom": "Site web", "terminé": true}
            ]
        }
    ]
}
'''

data = json.loads(reponse_api)

# Navigation dans les données imbriquées
for utilisateur in data["utilisateurs"]:
    print(f"\n{utilisateur['nom']} :")
    print(f"  Compétences : {', '.join(utilisateur['competences'])}")
    for projet in utilisateur["projets"]:
        statut = "✅" if projet["terminé"] else "⏳"
        print(f"  {statut} {projet['nom']}")

Bonnes pratiques

Pour utiliser efficacement le module json en Python, voici les bonnes pratiques que nous vous recommandons :

• Utilisez toujours ensure_ascii=False si vos données contiennent des caractères non-ASCII (accents, caractères spéciaux). Cela produit un JSON plus lisible et souvent plus compact.
• Gérez systématiquement les exceptions json.JSONDecodeError lorsque vous désérialisez des données provenant de sources externes. Ne faites jamais confiance à du JSON non validé.
• Utilisez indent pour le débogage et le stockage, mais retirez-le pour le transfert réseau. Un JSON compact réduit la bande passante.
• Préférez encoding="utf-8" à l'ouverture de tout fichier JSON pour garantir une compatibilité multiplateforme.
• Utilisez json.dumps() avec sort_keys=True si vous avez besoin de résultats déterministes (utile pour les comparaisons, le hachage ou le versioning).
• Ne stockez jamais de données sensibles (mots de passe, tokens) dans des fichiers JSON en clair. Utilisez des variables d'environnement ou des solutions de gestion de secrets.
• Utilisez les dict pour structurer vos données avant la sérialisation. La correspondance entre les dictionnaires Python et les objets JSON est directe et naturelle.
• Pensez aux dataclass pour modéliser des données structurées avant de les convertir en JSON. Elles offrent une meilleure lisibilité et une validation implicite des types.

Questions fréquentes

json.dumps() (avec un "s" pour "string") convertit un objet Python en une chaîne de caractères JSON que vous pouvez stocker dans une variable ou manipuler en mémoire. json.dump() (sans "s") écrit directement le JSON dans un fichier ouvert. La règle est simple : utilisez dumps/loads pour les chaînes et dump/load pour les fichiers.

Les tuple sont automatiquement convertis en tableaux JSON (arrays) lors de la sérialisation, tout comme les list. En revanche, les sets ne sont pas directement sérialisables et provoqueront une erreur TypeError. Pour les sérialiser, vous devez les convertir en listes, soit manuellement, soit en utilisant un encodeur personnalisé avec le paramètre default de json.dumps().

Le module json standard charge l'intégralité du fichier en mémoire, ce qui peut poser problème pour des fichiers de plusieurs gigaoctets. Pour ces cas d'usage, envisagez des bibliothèques comme ijson (parsing incrémental), orjson ou ujson (alternatives plus performantes). Pour la plupart des usages courants (fichiers de configuration, réponses d'API), le module standard est parfaitement adapté et suffisamment performant.

La manipulation de JSON est une compétence fondamentale pour tout développeur Python, que ce soit pour consommer des API, gérer des configurations ou échanger des données. Pour maîtriser ce sujet ainsi que l'ensemble de l'écosystème Python, nous vous recommandons de suivre notre formation dédiée à Python sur Believemy. Vous y apprendrez non seulement la manipulation de JSON, mais aussi toutes les compétences nécessaires pour devenir un développeur Python accompli.