Python Language
Sérialisation des données de pickle
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
etFalse
- nombres (de tous types)
- cordes (de tous types)
-
tuple
s,list
s,set
s etdict
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).
- des instances de telles classes dont le
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é.