Le module json

+------------------+-------------+
| Type JSON        | Type Python |
+------------------+-------------+
| string           | str         |
| number (integer) | int         |
| number (real)    | float       |
| object           | dict        |
| array            | list        |
| true             | True        |
| false            | False       |
| null             | None        |
+------------------+-------------+

json.dumps() -> Sérialise un objet Python en chaîne str JSON
json.loads() -> Désérialise une chaîne str JSON en objet Python

json.dump()  -> Écrit un objet Python dans un fichier JSON
json.load()  -> Lit un fichier JSON pour le convertir en objet Python

import json

# Notre ami Patrick et ses données
utilisateur = {
    "nom": "Patrick",
    "age": 35,
    "est_admin": True,
    "passions": ["Code", "Pétanque"],
    "coordonnees": (48.8566, 2.3522)  # Un tuple !
}

# Conversion en chaîne de caractères JSON
json_string = json.dumps(utilisateur)

print(type(json_string))  # Affiche : <class 'str'>
print(json_string)
# Le tuple converti en liste [] et le "é" transformé en code unicode :
# {"nom": "Patrick", "age": 35, "est_admin": true, "passions": ["Code", "P\u00e9tanque"], "coordonnees": [48.8566, 2.3522]}

import json

utilisateur = {
    "nom": "Sébastien",
    "age": 30,
    "est_admin": False,
    "passions": ["Vélo", "Cinéma"]
}

json_formate = json.dumps(
    utilisateur,
    indent=4,              # Aligne proprement avec 4 espaces d'indentation
    sort_keys=True,        # Trie les clés par ordre alphabétique
    ensure_ascii=False     # Indispensable pour garder nos accents intacts
)

print(json_formate)

"""
{
    "age": 30,
    "est_admin": false,
    "nom": "Sébastien",
    "passions": [
        "Vélo",
        "Cinéma"
    ]
}
"""

import json

reponse_api = '{"nom": "Patrick", "role": "admin", "score": null}'

# Conversion de la chaîne JSON en dictionnaire Python
donnees = json.loads(reponse_api)

print(type(donnees))  # Affiche : <class 'dict'>
print(donnees["nom"]) # Affiche : Patrick
print(donnees["score"]) # Affiche : None

import json

configuration = {
    "theme": "sombre",
    "notifications_actives": True,
    "langue": "fr"
}

with open("config.json", "w", encoding="utf-8") as fichier:
    json.dump(configuration, fichier, indent=4, ensure_ascii=False)
# indent=4 pour une meilleure lisibilité, ensure_ascii=False pour permettre les caractères spéciaux

print("Fichier de configuration sauvegardé pour Patrick ! 😎")

import json

with open("config.json", "r", encoding="utf-8") as fichier:
    config_recuperee = json.load(fichier)

print(config_recuperee["theme"])  # Affiche : sombre

import json

nom_fichier = "configuration.json"

try:
    with open(nom_fichier, "r", encoding="utf-8") as fichier:
        donnees = json.load(fichier)
    print("Données chargées avec succès !")

except FileNotFoundError:
    # On intercepte le cas où le fichier n'existe pas du tout
    print(f"Erreur : Le fichier '{nom_fichier}' est introuvable.")

except json.JSONDecodeError as erreur:
    # On intercepte le cas où le JSON contient des erreurs de syntaxe (mal formé)
    print("Erreur : Le fichier JSON est mal formé ou corrompu !")
    print(f"Détails de l'erreur : {erreur.msg} à la ligne {erreur.lineno}, colonne {erreur.colno}, position {erreur.pos}")

{
    "theme": "sombre",,
    "notifications_actives": true,
    "langue": "fr"
}

Erreur : Le fichier JSON est mal formé ou corrompu !
Détails de l'erreur : Expecting property name enclosed in double quotes à la ligne 2, colonne 23, position 24

import json

# Un dictionnaire avec une clé invalide pour du JSON (un tuple)
donnees_bizarres = {
    "cle_valide": "Ok",
    (1, 2): "Erreur potentielle !",
}

# Sans skipkeys=True, la ligne ci-dessous plante !
resultat = json.dumps(donnees_bizarres, skipkeys=True)
print(resultat)  # Affiche : {"cle_valide": "Ok"}

# Sans le skipkeys=True, TypeError: keys must be str, int, float, bool or None, not tuple

import json

donnees_scientifiques = {"valeur": float('nan')}


donnees_json = json.dumps(donnees_scientifiques)
print(donnees_json)
# {"valeur": NaN}

import json

donnees_scientifiques = {"valeur": float('nan')}

try:
    # On force le respect strict du standard JSON
    json.dumps(donnees_scientifiques, allow_nan=False)
except ValueError as e:
    print(f"Refus de sérialisation : {e}")
    # Refus de sérialisation : Out of range float values are not JSON compliant: nan

import json
from decimal import Decimal

json_facture = '{"total": 100.10}'

# On force l'utilisation de Decimal pour la précision financière
donnees = json.loads(json_facture, parse_float=Decimal)

print(type(donnees["total"]))  # Affiche : <class 'decimal.Decimal'>

import json
from collections import OrderedDict

json_donnees = '{"a": 1, "b": 2, "c": 3}'

donnees = json.loads(json_donnees, object_pairs_hook=OrderedDict)
print(type(donnees))  # Affiche : <class 'collections.OrderedDict'>

import json

# Un JSON avec deux fois la clé "score", ce qui est valide mais peu recommandé
json_bizarre = '{"joueur": "Patrick", "score": 100, "score": 250}'

# La première valeur (100) est perdue
donnees_classiques = json.loads(json_bizarre)
print(donnees_classiques) 
# Affiche : {'joueur': 'Patrick', 'score': 250}

# On force l'extraction en liste de tuples
donnees_brutes = json.loads(json_bizarre, object_pairs_hook=list)

print(donnees_brutes)
# [('joueur', 'Patrick'), ('score', 100), ('score', 250)]

import json
from datetime import datetime

class Commande:
    def __init__(self, reference, date_creation):
        self.reference = reference
        self.date_creation = date_creation

# Une simple fonction de traduction
def traduire_commande(objet):
    if isinstance(objet, Commande):
        return {"ref": objet.reference, "date": objet.date_creation.isoformat()}

    raise TypeError(f"Le type {type(objet)} n'est pas sérialisable")

ma_commande = Commande("CMD-42", datetime.now())

# On passe notre fonction au paramètre 'default'
print(json.dumps(ma_commande, default=traduire_commande, indent=2))

import json
from datetime import datetime

class Commande:
    def __init__(self, reference, date_creation):
        self.reference = reference
        self.date_creation = date_creation

# Notre classe d'encodage
class CommandeEncoder(json.JSONEncoder):
    def default(self, objet):
        if isinstance(objet, Commande):
            return {
                "reference": objet.reference,
                "date_creation": objet.date_creation.isoformat()
            }
        # Pour les types standards, on laisse faire l'encodeur parent via super()
        return super().default(objet)

ma_commande = Commande("CMD-42", datetime.now())

# On passe notre classe personnalisée au paramètre 'cls'
json_commande = json.dumps(ma_commande, cls=CommandeEncoder, indent=2)
print(json_commande)

import json

class Client:
    def __init__(self, nom, email):
        self.nom = nom
        self.email = email

    def __str__(self):
        return f"<Client {self.nom}>"

def json_vers_client(dictionnaire):
    if "nom" in dictionnaire and "email" in dictionnaire:
        return Client(dictionnaire["nom"], dictionnaire["email"])
    return dictionnaire

json_client = '{"nom": "Patrick", "email": "[email protected]"}'

# On récupère directement un objet Client
client_instancie = json.loads(json_client, object_hook=json_vers_client)
print(type(client_instancie))  # Affiche : <class '__main__.Client'>
print(client_instancie)        # Affiche : <Client Patrick>