Sérialisation binaire avec le module pickle

Dans de nombreux cas d'ingénierie logicielle et de science des données, les informations à sauvegarder ne sont pas de simples chaînes de texte, mais des objets Python complexes : des instances de classes personnalisées, des dictionnaires imbriqués de dictionnaires, des arbres de décision ou des modèles de Machine Learning entraînés (Scikit-Learn, PyTorch).

Convertir manuellement ces structures en texte brut serait laborieux et inefficace. C'est ici qu'intervient le module natif pickle.

---

1. Qu'est-ce que la sérialisation (Pickling) ?

• Sérialisation (Pickling) : conversion d'une hiérarchie d'objets Python en mémoire vive en un flux binaire continu d'octets (byte stream) pouvant être enregistré sur disque (.pkl) ou transmis sur un réseau.
• Désérialisation (Unpickling) : opération inverse qui reconstruit fidèlement l'objet Python initial en mémoire vive à partir du flux d'octets.

flowchart LR
    A[Objet Python en RAM : Modèle, Instance, Dict] -->|pickle.dump en mode wb| B[Fichier binaire .pkl sur disque]
    B -->|pickle.load en mode rb| C[Objet Python réincarné à l'identique en RAM]

---

2. Sauvegarder et recharger un objet : dump() et load()

[!IMPORTANT] Les fichiers manipulés avec pickle sont des fichiers binaires. Vous devez obligatoirement utiliser les modes "wb" (écriture binaire) et "rb" (lecture binaire).

import pickle

# Données complexes en mémoire
etat_jeu = {
    "joueur": "Koffi",
    "niveau": 4,
    "score": 14250,
    "inventaire": ["epee", "potion", "bouclier"],
    "coordonnees": (14.5, 89.2)
}

# 1. Sauvegarde dans un fichier binaire (.pkl)
with open("sauvegarde.pkl", "wb") as f:
    pickle.dump(etat_jeu, f)

print("Partie sauvegardee avec succes dans 'sauvegarde.pkl'.")

# 2. Rechargement fidèle de l'objet
with open("sauvegarde.pkl", "rb") as f:
    partie_chargee = pickle.load(f)

print("Partie rechargee :", partie_chargee["joueur"], "- Score :", partie_chargee["score"])
print("Type restitue   :", type(partie_chargee))  # <class 'dict'>

---

3. Sérialisation en mémoire vive : dumps() et loads()

Si vous souhaitez convertir un objet en octets en mémoire (par exemple pour l'enregistrer dans une base Redis ou l'envoyer via un socket réseau sans passer par le disque dur) :

• pickle.dumps(obj) : (Dump String) retourne les octets bruts (bytes).
• pickle.loads(octets) : (Load String) recrée l'objet depuis les octets bruts.

import pickle

donnees = [10, 20, 30]
flux_octets = pickle.dumps(donnees)
print("Flux binaire :", flux_octets)  # b'\x80\x04\x95\x0b\x00...'

copie_identique = pickle.loads(flux_octets)
print("Objet restaure :", copie_identique)

---

4. Pickle vs JSON : Comparatif technique

Critère	Module pickle	Module json
Format	Binaire propriétaire Python	Texte standard universel (RFC 8259)
Interopérabilité	Python uniquement (illisible en Java, C, JS)	Universel (tous langages et web)
Types supportés	Presque tous les objets Python (classes, tuples, sets)	Limité : dict, list, str, int, float, bool, None
Lisibilité humaine	Illisible sans Python	Parfaitement lisible dans un éditeur
Sécurité	Dangereux avec des sources inconnues	Sûr (ne contient pas de code exécutable)

---

5. Avertissement critique de cybersécurité

[!CAUTION] Ne désérialisez JAMAIS un fichier pickle d'origine inconnue ou non vérifiée !
Le protocole pickle n'est pas sécurisé contre les attaques malveillantes. Un attaquant peut concevoir un fichier pickle forgé qui exécutera du code système arbitraire dès l'appel à pickle.load(). Pour échanger des données avec des utilisateurs ou des API externes, utilisez exclusivement le format JSON.

---

6. Mise en pratique : Sauvegarde d'un modèle d'analyse

Concevons une classe d'analyse statistique et illustrons comment sauvegarder son état entraîné sur disque :

import pickle

class ModeleStatistique:
    def __init__(self, nom_modele: str):
        self.nom = nom_modele
        self.poids = []
        self.est_entraine = False

    def entrainer(self, observations: list[float]):
        # Simulation d'un apprentissage
        self.poids = [x * 1.5 for x in observations]
        self.est_entraine = True
        print(f"Modele '{self.nom}' entraine avec succes.")

    def predire(self, valeur: float) -> float:
        if not self.est_entraine:
            raise RuntimeError("Le modele doit etre entraine avant de predire !")
        return valeur * (sum(self.poids) / len(self.poids))

# Étape 1 : Entraînement et sauvegarde
modele = ModeleStatistique("Regresseur_Ventes")
modele.entrainer([1.0, 2.0, 3.0, 4.0])

with open("modele_ventes.pkl", "wb") as f:
    pickle.dump(modele, f)

# Étape 2 : Chargement ultérieur et prédiction
with open("modele_ventes.pkl", "rb") as f:
    modele_recharge = pickle.load(f)

prediction = modele_recharge.predire(10.0)
print(f"Prediction effectuee avec le modele recharge : {prediction:.2f}")

---

7. Défi d'application

Créez un script qui prend un dictionnaire de session utilisateur, le sérialise avec pickle.dumps(), calcule l'empreinte de contrôle SHA-256 de ce flux binaire (avec le module hashlib.sha256), puis simule la désérialisation après avoir vérifié que l'intégrité du flux n'a pas été corrompue.

Partagez sur les réseaux sociaux

Commentaires