Python pickle : la sé­ria­li­sa­tion des objets en Python

Avec Python pickle, il est possible de sé­ria­li­ser des objets et de les dé­sé­ria­li­ser par la suite. De nombreux types de données peuvent être convertis, comme des listes, des dic­tion­naires, ou encore des classes per­son­na­li­sées, pour les sau­ve­gar­der, les trans­mettre ou les réu­ti­li­ser fa­ci­le­ment. Découvrez dans cet article comment fonc­tionne ce module, ses prin­ci­pales méthodes, et des exemples pratiques pour maîtriser la sé­ria­li­sa­tion et la dé­sé­ria­li­sa­tion en Python.

Qu’est-ce que Python pickle ?

Le module Python pickle est un outil puissant pour sé­ria­li­ser des objets, c’est-à-dire les convertir en un format binaire afin de les sau­ve­gar­der, les trans­mettre ou les réu­ti­li­ser ul­té­rieu­re­ment. Cette pratique, appelée sé­ria­li­sa­tion, est par­ti­cu­liè­re­ment utile pour en­re­gis­trer des struc­tures complexes comme des listes, des dic­tion­naires ou des objets de classe.

Le processus inverse, connu sous le nom de dé­sé­ria­li­sa­tion (un­pi­ck­ling), permet de re­cons­truire un objet à partir de ce format binaire, en res­tau­rant toutes ses in­for­ma­tions. Ainsi, une fois sérialisé, un objet peut être réutilisé sans né­ces­si­ter une re­créa­tion complète.

Python pickle convertit les objets en un flux d’octets et fournit les ins­truc­tions né­ces­saires pour une dé­sé­ria­li­sa­tion réussie, ga­ran­tis­sant que la structure originale est re­cons­truite avec précision. Ces fonc­tion­na­li­tés per­met­tent un gain de temps con­si­dé­rable, notamment lorsqu’il s’agit de réu­ti­li­ser fré­quem­ment les mêmes objets. Par défaut, les fichiers générés avec pickle sont en­re­gis­trés au format .pkl.

Ces opé­ra­tions sont réalisées à l’aide des méthodes comme pickle.dump() pour la sé­ria­li­sa­tion pickle.load() pour la dé­sé­ria­li­sa­tion.

Quels types de données peuvent être convertis ?

Python pickle peut sé­ria­li­ser les types de données suivants :

• Valeurs boo­léennes : True et False ainsi que ainsi que None
• Entiers et nombres complexes
• Chaînes de ca­rac­tères (normales et unicode)
• Listes
• Sets
• Tuples Python
• Ré­per­toires composés uni­que­ment d’objets cor­res­pon­dants
• 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é­ria­li­sés. Si vous essayez de sé­ria­li­ser ces types, Python pickle renverra une erreur.

Quelles sont les dif­fé­rentes méthodes dis­po­nibles ?

Pour tra­vail­ler 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é­ria­li­sa­tion 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é­ria­li­sa­tion, 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é­ria­li­sa­tion 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é­ria­li­sa­tion, mais opère avec une chaîne d’octets.

Pour dis­tin­guer les méthodes, voici un moyen mné­mo­tech­nique : retenez que le « s » dans pickle.dumps et pickle.loads signifie « string » (chaîne de ca­rac­tères en anglais).

Exemple de Python pickle

Pour mieux illustrer le fonc­tion­ne­ment de Python pickle, nous allons tra­vail­ler 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é­via­tion 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 sau­ve­gar­der la liste « couleurs » dans ce fichier. Enfin, le fichier est au­to­ma­ti­que­ment fermé.

Convertir le fichier de sau­ve­garde dans son format d’origine

Si vous souhaitez dé­sé­ria­li­ser un fichier binaire, utilisez la méthode Python pickle.load(). Le code suivant permet de re­con­ver­tir l’objet dans son format d’origine et de lancer une sortie. Nous ajoutons l’abré­via­tion 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é­ria­li­ser un dic­tion­naire avec Python pickle

Même des types de données plus complexes, comme les ré­per­toires, peuvent être fa­ci­le­ment sé­ria­li­sés avec Python pickle et ensuite re­con­ver­tis dans leur forme originale. Pour cela, nous com­men­çons par créer un ré­per­toire nommé « Personnes ». Nous y déposons quelques données dif­fé­rentes sur dif­fé­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, con­ver­tis­sons les données, puis les re­con­ver­tis­sons à nouveau pour tester la sé­ria­li­sa­tion de ce ré­per­toire :

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 main­te­nant accéder à ces in­for­ma­tions 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 ca­rac­tères

Dans l’exemple suivant, nous utilisons Python pickle pour en­re­gis­trer une classe dans une chaîne de ca­rac­tères. Cette classe contient des types de données to­ta­le­ment dif­fé­rents, mais qui peuvent tous être pris en compte. Nous allons donc créer une classe appelée « Clas­seExemple » et la sé­ria­li­ser. Voici le code cor­res­pon­dant :

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 re­con­ver­tie 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}

Com­pres­ser les objets sé­ria­li­sés

En principe, les fichiers stockés avec Python pickle sont re­la­ti­ve­ment compacts. Cependant, il est possible, et parfois re­com­mandé, de com­pres­ser encore plus les fichiers mémoire. Cela fonc­tionne par exemple avec le programme de com­pres­sion gratuit bzip2, qui fait partie de la bi­blio­thèque standard de ce langage de pro­gram­ma­tion. Dans l’exemple suivant, nous créons une chaîne de ca­rac­tères, nous la sé­ria­li­sons, puis nous ap­pli­quons le programme de com­pres­sion :

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 tra­vail­ler avec Python pickle

Bien que Python pickle soit une méthode pratique et efficace pour convertir des objets, il y a un in­con­vé­nient majeur dont vous devez tenir compte lorsque vous tra­vail­lez avec ce module : il est possible de trans­por­ter du code mal­veil­lant via des données sé­ria­li­sé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é­ria­li­sez donc que des fichiers dont vous con­nais­sez la source et en qui vous avez confiance !