Recherche…


Syntaxe

  • pickle.dump (objet, fichier, protocole) #Pour sérialiser un objet

  • pickle.load (file) #Pour désérialiser un objet

  • pickle.dumps (objet, protocole) # Pour sérialiser un objet en octets

  • pickle.loads (buffer) # Pour désérialiser un objet à partir d'octets

Paramètres

Paramètre Détails
objet L'objet à stocker
fichier Le fichier ouvert qui contiendra l'objet
protocole Le protocole utilisé pour décrocher l'objet (paramètre facultatif)
tampon Un objet octets contenant un objet sérialisé

Remarques

Types de picklables

Les objets suivants sont picklable.

  • None , True et False
  • nombres (de tous types)
  • cordes (de tous types)
  • tuple s, list s, set s et dict contenant uniquement des objets picklable
  • fonctions définies au niveau supérieur d'un module
  • fonctions intégrées
  • classes définies au niveau supérieur d'un module
    • des instances de telles classes dont le __dict__ ou le résultat de l'appel de __getstate__() est picklable (voir les documents officiels pour plus de détails).

Basé sur la documentation officielle de Python .

pickle et sécurité

Le module de pickle n'est pas sécurisé . Il ne doit pas être utilisé lors de la réception de données sérialisées provenant d'une partie non fiable, par exemple sur Internet.

Utiliser Pickle pour sérialiser et désérialiser un objet

Le module pickle implémente un algorithme pour transformer un objet Python arbitraire en une série d'octets. Ce processus est également appelé sérialisation de l'objet. Le flux d'octets représentant l'objet peut alors être transmis ou stocké, puis reconstruit pour créer un nouvel objet avec les mêmes caractéristiques.

Pour le code le plus simple, nous utilisons les fonctions dump() et load() .

Pour sérialiser l'objet

import pickle

# An arbitrary collection of objects supported by pickle.
data = {
    'a': [1, 2.0, 3, 4+6j],
    'b': ("character string", b"byte string"),
    'c': {None, True, False}
}

with open('data.pickle', 'wb') as f:
    # Pickle the 'data' dictionary using the highest protocol available.
    pickle.dump(data, f, pickle.HIGHEST_PROTOCOL)

Désérialiser l'objet

import pickle

with open('data.pickle', 'rb') as f:
    # The protocol version used is detected automatically, so we do not
    # have to specify it.
    data = pickle.load(f)

Utilisation d'objets pickle et byte

Il est également possible de sérialisation dans et désérialiser à partir d'objets d'octets, en utilisant les dumps et loads fonction, qui sont équivalentes à dump et load .

serialized_data = pickle.dumps(data, pickle.HIGHEST_PROTOCOL)
# type(serialized_data) is bytes

deserialized_data = pickle.loads(serialized_data)
# deserialized_data == data

Personnaliser les données marinées

Certaines données ne peuvent pas être décapées. Les autres données ne doivent pas être décapées pour d'autres raisons.

Ce qui sera décapé peut être défini dans la méthode __getstate__ . Cette méthode doit renvoyer quelque chose qui est picklable.

Sur le côté opposé, __setstate__ : il recevra ce que __getstate__ créé et doit initialiser l'objet.

class A(object):
    def __init__(self, important_data):
        self.important_data = important_data
        
        # Add data which cannot be pickled:
        self.func = lambda: 7
        
        # Add data which should never be pickled, because it expires quickly:
        self.is_up_to_date = False
    
    def __getstate__(self):
        return [self.important_data] # only this is needed
    
    def __setstate__(self, state):
        self.important_data = state[0]
        
        self.func = lambda: 7  # just some hard-coded unpicklable function
        
        self.is_up_to_date = False  # even if it was before pickling

Maintenant, cela peut être fait:

>>> a1 = A('very important')
>>>
>>> s = pickle.dumps(a1)  # calls a1.__getstate__()
>>>
>>> a2 = pickle.loads(s)  # calls a1.__setstate__(['very important'])
>>> a2
<__main__.A object at 0x0000000002742470>
>>> a2.important_data
'very important'
>>> a2.func()
7

L'implémentation ici affiche une liste avec une valeur: [self.important_data] . C'était juste un exemple, __getstate__ aurait pu retourner tout ce qui est picklable, tant que __setstate__ sait comment oppoisite. Une bonne alternative est un dictionnaire de toutes les valeurs: {'important_data': self.important_data} .

Le constructeur n'est pas appelé! Notez que dans l'exemple précédent, l'instance a2 été créée dans pickle.loads sans jamais appeler A.__init__ , donc A.__setstate__ devait initialiser tout ce que __init__ aurait initialisé s'il était appelé.



Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow