1. À propos de JSON et son module natif en Python
JSON (JavaScript Object Notation) est un format léger d'échange de données, largement utilisé pour structurer des informations de manière lisible par l'homme et facilement interprétable par les machines. En Python, le module json (intégré dans la bibliothèque standard) permet de convertir des données Python vers JSON et vice-versa. Ce processus est appelé sérialisation (Python → JSON) et désérialisation (JSON → Python).
Les correspondances types principaux sont : dict → objet JSON, list → tableau JSON, str → chaîne JSON, int/float → nombre JSON, bool → booléen JSON, None → null JSON.
2. Sérialisation : Convertir des objets Python en JSON
La sérialisation transforme un objet Python (généralement un dictionnaire ou une liste) en une chaîne de caractères au format JSON. Cela est essentiel pour envoyer des données via une API ou les sauvegarder dans un fichier.
2.1 Utilisation de json.dumps() pour créer une chaîne JSON
La fonction json.dumps() prend un objet Python et retourne une chaîne JSON. Les paramètres comme indent permettent de formater le résultat pour le rendre lisible.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
import json # Objet Python : dictionnaire avec différents types data_python = { "nom": "Serveur Central", "actif": True, "cpu": 4.2, "ports": [8080, 443, 22], "tags": None } # Conversion en chaîne JSON avec indentation json_string = json.dumps(data_python, indent=4) print(json_string) # Sortie : # { # "nom": "Serveur Central", # "actif": true, # "cpu": 4.2, # "ports": [ # 8080, # 443, # 22 # ], # "tags": null # } |
2.2 Écrire directement dans un fichier avec json.dump()
Pour sauvegarder des données JSON directement dans un fichier, on utilise json.dump(). Cette méthode évite de créer une chaîne intermédiaire et écrit directement dans l'objet fichier.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import json configuration = { "version": "1.0.2", "debug": False, "plugins": ["monitoring", "logging"] } # Ouverture du fichier en écriture et écriture du JSON with open("config.json", "w", encoding="utf-8") as fichier: json.dump(configuration, fichier, indent=4) print("Fichier config.json créé avec succès.") # Sortie : # Fichier config.json créé avec succès. # (Le fichier contient la structure JSON indentée) |
3. Désérialisation : Lire et convertir du JSON en Python
La désérialisation est l'opération inverse : à partir d'une chaîne JSON ou d'un fichier, on reconstruit des objets Python natifs (dictionnaires, listes, etc.).
3.1 Analyser une chaîne JSON avec json.loads()
La fonction json.loads() prend une chaîne de caractères au format JSON et la convertit en objet Python correspondant.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import json # Chaîne JSON reçue (par exemple depuis une API) reponse_json = '{"statut": "succès", "code": 200, "donnees": {"utilisateur": "admin"}}' # Conversion en dictionnaire Python objet_python = json.loads(reponse_json) print(type(objet_python)) # <class 'dict'> print(objet_python["statut"]) # succès print(objet_python["donnees"]["utilisateur"]) # admin # Sortie : # <class 'dict'> # succès # admin |
3.2 Lire un fichier JSON avec json.load()
Lorsque les données JSON sont stockées dans un fichier, json.load() permet de les lire et de les convertir directement en objets Python.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import json # Créons d'abord un exemple de fichier JSON with open("exemple.json", "w", encoding="utf-8") as f: json.dump({"service": "api", "version": 3}, f) # Lecture et désérialisation depuis le fichier with open("exemple.json", "r", encoding="utf-8") as fichier: donnees = json.load(fichier) print(donnees["service"]) # api print(donnees["version"]) # 3 # Sortie : # api # 3 |
4. Gérer les erreurs et les types complexes
Le module JSON de Python ne peut pas sérialiser nativement tous les types Python (ex: datetime, Decimal). Pour cela, on utilise des paramètres avancés comme default ou object_hook.
4.1 Gestion des erreurs de parsing avec JSONDecodeError
Il est important de capturer les exceptions lorsque le JSON source est malformé. L'erreur json.JSONDecodeError permet d'identifier ces situations.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import json json_invalide = '{"nom": "test", "valeur": }' # JSON invalide try: data = json.loads(json_invalide) except json.JSONDecodeError as e: print(f"Erreur de parsing JSON : {e}") print(f"Position approximative : {e.pos}") # Sortie : # Erreur de parsing JSON : Expecting value: line 1 column 27 (char 26) # Position approximative : 26 |
4.2 Sérialiser des objets personnalisés (ex: datetime)
Pour sérialiser un objet datetime, on définit une fonction de conversion passée au paramètre default de dumps(). Cette fonction transforme l'objet non sérialisable en un format JSON compréhensible.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
import json from datetime import datetime def convertisseur_json(obj): """Convertit les objets datetime en chaîne ISO.""" if isinstance(obj, datetime): return obj.isoformat() # Lève une exception pour les autres types non gérés raise TypeError(f"Type {type(obj)} non sérialisable") maintenant = datetime.now() donnees = { "evenement": "Sauvegarde", "timestamp": maintenant } json_str = json.dumps(donnees, default=convertisseur_json, indent=2) print(json_str) # Sortie (exemple) : # { # "evenement": "Sauvegarde", # "timestamp": "2025-03-23T14:35:12.123456" # } |
5. Optimisation et bonnes pratiques pour les gros volumes
Lors du traitement de fichiers JSON volumineux, il est recommandé d'utiliser des lectures incrémentales ou des itérateurs pour éviter de charger l'intégralité des données en mémoire.
5.1 Lecture incrémentale avec json.JSONDecoder
L'utilisation de json.JSONDecoder.raw_decode() permet de lire un JSON à partir d'une position donnée, ce qui est utile pour extraire plusieurs objets JSON d'un même flux.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import json # Flux contenant deux objets JSON distincts flux = '{"id": 1, "nom": "Alpha"}{"id": 2, "nom": "Beta"}' decodeur = json.JSONDecoder() idx = 0 while idx < len(flux): objet, taille = decodeur.raw_decode(flux, idx) print(objet) idx += taille # Sortie : # {'id': 1, 'nom': 'Alpha'} # {'id': 2, 'nom': 'Beta'} |
5.2 Utilisation de ijson pour les fichiers très volumineux
Pour des fichiers JSON de plusieurs gigaoctets, la bibliothèque externe ijson (non intégrée mais populaire) permet un parsing itératif. Ici nous illustrons une approche similaire avec le module json standard en lisant ligne par ligne si le fichier contient un objet JSON par ligne.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
import json import tempfile # Création d'un fichier exemple avec un objet JSON par ligne contenu_lignes = [ '{"user": "alice", "score": 98}', '{"user": "bob", "score": 85}' ] with tempfile.NamedTemporaryFile(mode="w+", suffix=".jsonl", delete=False) as tmp: for ligne in contenu_lignes: tmp.write(ligne + "\n") nom_fichier = tmp.name # Lecture ligne par ligne pour éviter de tout charger en mémoire with open(nom_fichier, "r", encoding="utf-8") as f: for num_ligne, ligne in enumerate(f, 1): objet = json.loads(ligne) print(f"Ligne {num_ligne} : {objet['user']} -> {objet['score']}") # Sortie : # Ligne 1 : alice -> 98 # Ligne 2 : bob -> 85 |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
