Python pickle : la sérialisation des objets en Python

Avec Python pickle, il est possible de sérialiser des objets et de les désérialiser par la suite. De nombreux types de données peuvent être convertis, comme des listes, des dictionnaires, ou encore des classes personnalisées, pour les sauvegarder, les transmettre ou les réutiliser facilement. Découvrez dans cet article comment fonctionne ce module, ses principales méthodes, et des exemples pratiques pour maîtriser la sérialisation et la désérialisation en Python.

Qu’est-ce que Python pickle ?

Le module Python pickle est un outil puissant pour sérialiser des objets, c’est-à-dire les convertir en un format binaire afin de les sauvegarder, les transmettre ou les réutiliser ultérieurement. Cette pratique, appelée sérialisation, est particulièrement utile pour enregistrer des structures complexes comme des listes, des dictionnaires ou des objets de classe.

Le processus inverse, connu sous le nom de désérialisation (unpickling), permet de reconstruire un objet à partir de ce format binaire, en restaurant toutes ses informations. Ainsi, une fois sérialisé, un objet peut être réutilisé sans nécessiter une recréation complète.

Python pickle convertit les objets en un flux d’octets et fournit les instructions nécessaires pour une désérialisation réussie, garantissant que la structure originale est reconstruite avec précision. Ces fonctionnalités permettent un gain de temps considérable, notamment lorsqu’il s’agit de réutiliser fréquemment les mêmes objets. Par défaut, les fichiers générés avec pickle sont enregistrés au format .pkl.

Ces opérations sont réalisées à l’aide des méthodes comme pickle.dump() pour la sérialisation pickle.load() pour la désérialisation.

Quels types de données peuvent être convertis ?

Python pickle peut sérialiser les types de données suivants :

• Valeurs booléennes : True et False ainsi que ainsi que None
• Entiers et nombres complexes
• Chaînes de caractères (normales et unicode)
• Listes
• Sets
• Tuples Python
• Répertoires composés uniquement d’objets correspondants
• Fonctions
• Classes Python

Certains objets, comme les fichiers ouverts, les sockets réseau ou les threads en cours d’exécution, ne peuvent pas être sérialisés. Si vous essayez de sérialiser ces types, Python pickle renverra une erreur.

Quelles sont les différentes méthodes disponibles ?

Pour travailler avec Python pickle, il existe quatre méthodes à l’intérieur du module :

• pickle.dump(obj, file, protocol=None, *, fix_imports=True, buffer_callback=None) : est utilisé pour la sérialisation et crée un fichier avec le résultat souhaité.
• pickle.dumps(obj, protocol=None, *, fix_imports=True, buffer_callback=None) : est également utilisé pour la sérialisation, mais renvoie une chaîne d’octets.
• pickle.load(file, *, fix_imports=True, encoding='ASCII', errors="strict", buffers=None) : est utilisé pour la désérialisation en lisant le fichier stocké.
• pickle.loads(bytes_object, *, fix_imports=True, encoding="ASCII", errors="strict", buffers=None) : est également utilisé pour la désérialisation, mais opère avec une chaîne d’octets.

Pour distinguer les méthodes, voici un moyen mnémotechnique : retenez que le « s » dans pickle.dumps et pickle.loads signifie « string » (chaîne de caractères en anglais).

Exemple de Python pickle

Pour mieux illustrer le fonctionnement de Python pickle, nous allons travailler avec un exemple simple. Pour cela, nous allons créer une liste simple contenant quatre couleurs. Voici notre code :

import pickle
couleurs = ['bleu', 'rouge', 'jaune', 'orange']

Ensuite, nous ouvrons un fichier texte au format .pkl et utilisons pickle.dump() pour y stocker notre liste. Pour cela, nous utilisons ce code :

with open('fichier_couleurs.pkl', 'wb') as f:
pickle.dump(couleurs, f)

L’abréviation wb indique au système d’ouvrir le fichier sous forme binaire. Cela permet également de sortir les données qu’il contient sous forme d’objets octets. La fonction dump() permet ensuite de sauvegarder la liste « couleurs » dans ce fichier. Enfin, le fichier est automatiquement fermé.

Convertir le fichier de sauvegarde dans son format d’origine

Si vous souhaitez désérialiser un fichier binaire, utilisez la méthode Python pickle.load(). Le code suivant permet de reconvertir l’objet dans son format d’origine et de lancer une sortie. Nous ajoutons l’abréviation rb, qui signifie « read binary ».

with open('fichier_couleurs.pkl', 'rb') as f:
couleurs_deserialisees = pickle.load(f)
print(couleurs_deserialisees)

Nous obtenons ainsi la sortie suivante :

['bleu', 'rouge', 'jaune', 'orange']

Sérialiser un dictionnaire avec Python pickle

Même des types de données plus complexes, comme les répertoires, peuvent être facilement sérialisés avec Python pickle et ensuite reconvertis dans leur forme originale. Pour cela, nous commençons par créer un répertoire nommé « Personnes ». Nous y déposons quelques données différentes sur différentes personnes :

import pickle
personnes = {
'Personne 1': {
'Nom': "Marie", 'Âge': 56, 'Ville': "Paris"
},
'Personne 2': {
'Nom': "Paul", 'Âge': 66, 'Ville': "Paris"
},
'Personne 3': {
'Nom': "Lisa", 'Âge': 22, 'Ville': "Marseille"
},
'Personne 4': {
'Nom': "Laure", 'Âge': 34, 'Ville': "Lille"
}
}

Dans le code suivant, nous créons donc un nouveau fichier, convertissons les données, puis les reconvertissons à nouveau pour tester la sérialisation de ce répertoire :

with open("personnes_dict.pkl", "wb") as f:
pickle.dump(personnes, f)
with open("personnes_dict.pkl", "rb") as f:
dict_deserialise = pickle.load(f)
print(dict_deserialise)

La sortie obtenue ressemble alors à ceci :

personnes = {
    'Personne 1': { 'Nom': "Marie", 'Âge': 56, 'Ville': "Paris"},
    'Personne 2': { 'Nom': "Paul", 'Âge': 66, 'Ville': "Paris"},
    'Personne 3': { 'Nom': "Lisa", 'Âge': 22, 'Ville': "Marseille"},
    'Personne 4': { 'Nom': "Laure", 'Âge': 34, 'Ville': "Lille"}
}

Vous pouvez maintenant accéder à ces informations comme d’habitude. Par exemple, nous demandons la sortie suivante :

# Définir le dictionnaire
dict_deserialise = {
    'Personne 1': {'Nom': "Marie", 'Âge': 56, 'Ville': "Paris"},
    'Personne 2': {'Nom': "Paul", 'Âge': 66, 'Ville': "Paris"},
    'Personne 3': {'Nom': "Lisa", 'Âge': 22, 'Ville': "Marseille"},
    'Personne 4': {'Nom': "Laure", 'Âge': 34, 'Ville': "Lille"}
}
# Imprimer la sortie
print(
    "Le nom de la troisième personne est "
    + dict_deserialise["Personne 3"]["Nom"]
    + " et elle a "
    + str(dict_deserialise["Personne 3"]["Âge"])
    + " ans."
)

Voici à quoi ressemble notre sortie :

Le nom de la troisième personne est Lisa et elle a 22 ans.

Convertir une classe en une chaîne de caractères

Dans l’exemple suivant, nous utilisons Python pickle pour enregistrer une classe dans une chaîne de caractères. Cette classe contient des types de données totalement différents, mais qui peuvent tous être pris en compte. Nous allons donc créer une classe appelée « ClasseExemple » et la sérialiser. Voici le code correspondant :

import pickle
class ClasseExemple:
    def __init__(self):
        self.a_number = 17
        self.a_list = [5, 10, 15]
        self.a_tuple = (18, 19)
        self.a_string = "bonjour"
        self.a_dict = {"couleur": "bleu", "chiffre": 3}
objet_exemple = ClasseExemple()
objet_serialise = pickle.dumps(objet_exemple)
print(f"Voici l’objet sérialisé :\n{objet_serialise}\n")
objet_exemple.a_dict = None
objet_deserialise = pickle.loads(objet_serialise)
print(f"Voici le a_dict de l’objet désérialisé :\n{objet_deserialise.a_dict}\n")

Après avoir sérialisé la classe, puis l’avoir reconvertie dans son format d’origine, nous obtenons cette sortie :

Voici l’objet sérialisé :
b'\x80\x03c__main__\nClasseExemple\nq\x00)\x81q\x01.'
Voici le a_dict de l’objet désérialisé :
{'couleur': 'bleu', 'chiffre': 3}

Compresser les objets sérialisés

En principe, les fichiers stockés avec Python pickle sont relativement compacts. Cependant, il est possible, et parfois recommandé, de compresser encore plus les fichiers mémoire. Cela fonctionne par exemple avec le programme de compression gratuit bzip2, qui fait partie de la bibliothèque standard de ce langage de programmation. Dans l’exemple suivant, nous créons une chaîne de caractères, nous la sérialisons, puis nous appliquons le programme de compression :

import pickle
import bz2
exemple_chaine = """Almost heaven, West Virginia
Blue Ridge Mountains, Shenandoah River
Life is old there, older than the trees
Younger than the mountains, growin' like a breeze
Country roads, take me home
To the place I belong
West Virginia, mountain mama
Take me home, country roads."""
serialise = pickle.dumps(exemple_chaine)
compresse = bz2.compress(serialise)

Note de sécurité pour travailler avec Python pickle

Bien que Python pickle soit une méthode pratique et efficace pour convertir des objets, il y a un inconvénient majeur dont vous devez tenir compte lorsque vous travaillez avec ce module : il est possible de transporter du code malveillant via des données sérialisées. Cela ne pose pas de problème lorsque vous utilisez vos propres données, mais il faut faire attention aux fichiers étrangers. Ne désérialisez donc que des fichiers dont vous connaissez la source et en qui vous avez confiance !