# 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.

Conseil Comme du code malveillant peut être stocké dans un fichier mémoire, vous ne devez convertir au format original que des fichiers provenant de sources fiables.

## Quels types de données peuvent être convertis ?

Python `pickle` peut sérialiser les [types de données](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-data-types/) 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](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/tuples-en-python/)
- Répertoires composés uniquement d’objets correspondants
- Fonctions
- [Classes Python](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/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 :

```python
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 :

```python
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* ».

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

Nous obtenons ainsi la sortie suivante :

```python
['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 :

```python
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 :

```python
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 :

```python
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 :

```python
# 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 :

```python
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 :

```python
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 :

```python
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](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/quel-langage-de-programmation-apprendre/). Dans l’exemple suivant, nous créons une chaîne de caractères, nous la sérialisons, puis nous appliquons le programme de compression :

```python
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 !

Conseil Déploiement direct via GitHub : avec [Deploy Now](https://www.ionos.fr/hebergement/deploy-now "Deploy Now de IONOS") de IONOS, vous bénéficiez non seulement de la détection automatique du framework et d’une installation rapide, mais vous avez également le choix entre différents types de tarifs. Trouvez la solution qui correspond parfaitement à vos besoins !


This is a markdown version of: [https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-pickle/](https://www.ionos.fr/digitalguide/sites-internet/developpement-web/python-pickle/) for AI/LLM consumption.