Comprendre le pickling dans Python
J'ai récemment eu un devoir pour lequel je dois mettre un dictionnaire (où chaque clé fait référence à une liste) sous forme de vinaigre. Le seul problème est que je n'ai aucune idée de ce qu'est la forme marinée. Est-ce que quelqu'un pourrait me diriger dans la bonne direction avec quelques bonnes ressources pour m'aider à apprendre ce concept? Merci!
Le module pickle implémente un algorithme fondamental mais puissant pour la sérialisation et la désérialisation d'une structure d'objet Python).
Pickling - est le processus par lequel une hiérarchie d'objet Python est convertie en un flux d'octets, et Unpickling - est l'opération inverse, par laquelle un flux d'octets est reconverti en une hiérarchie d'objets.
Pickling (et unpickling) est également connu sous le nom de sérialisation , marshalling , ou aplatissement .
import pickle
data1 = {'a': [1, 2.0, 3, 4+6j],
'b': ('string', u'Unicode string'),
'c': None}
selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)
output = open('data.pkl', 'wb')
# Pickle dictionary using protocol 0.
pickle.dump(data1, output)
# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)
output.close()
Pour lire à partir d'un fichier mariné -
import pprint, pickle
pkl_file = open('data.pkl', 'rb')
data1 = pickle.load(pkl_file)
pprint.pprint(data1)
data2 = pickle.load(pkl_file)
pprint.pprint(data2)
pkl_file.close()
Tandis que d’autres ont souligné la Python documentation sur le module pickle, qui est une excellente ressource, vous pouvez également consulter Chapitre 13: Sérialisation Python = Objets de plonger dans Python 3 par Mark Pilgrim.
Pickling est un mini-langage qui peut être utilisé pour convertir l’état pertinent d’un objet python en une chaîne, où cette chaîne représente de manière unique l’objet. Ensuite, le décapage peut être utilisé pour convertir la chaîne en un objet actif, en "reconstruisant" l'objet à partir de l'état sauvegardé à l'origine de la chaîne.
>>> import pickle
>>>
>>> class Foo(object):
... y = 1
... def __init__(self, x):
... self.x = x
... return
... def bar(self, y):
... return self.x + y
... def baz(self, y):
... Foo.y = y
... return self.bar(y)
...
>>> f = Foo(2)
>>> f.baz(3)
5
>>> f.y
3
>>> pickle.dumps(f)
"ccopy_reg\n_reconstructor\np0\n(c__main__\nFoo\np1\nc__builtin__\nobject\np2\nNtp3\nRp4\n(dp5\nS'x'\np6\nI2\nsb."
Ce que vous pouvez voir ici, c'est que pickle n'enregistre pas le code source de la classe, mais stocke une référence à la définition de la classe. En gros, vous pouvez presque lire la chaîne choisie… il est dit (traduit grossièrement) "appelez le reconstructeur de copy_reg où les arguments sont la classe définie par __main__.Foo et ensuite faire d'autres choses ". L'autre chose est l'état enregistré de l'instance. Si vous regardez plus en profondeur, vous pouvez extraire que" chaîne x "est définie sur" l'entier 2 "(grosso modo: S'x'\np6\nI2). C’est en fait une partie coupée de la chaîne pickled pour une entrée de dictionnaire… le dict étant f.__dict__, lequel est {'x': 2}. Si vous examinez le code source de pickle, il indique très clairement une traduction pour chaque type d’objet et opération à partir de python en code octet décapé).
Notez également qu'il existe différentes variantes de la langue de décapage. Le protocole par défaut est le protocole 0, qui est plus lisible par l'homme. Il existe également le protocole 2, présenté ci-dessous (et les protocoles 1,3 et 4, en fonction de la version de python que vous utilisez).
>>> pickle.dumps([1,2,3])
'(lp0\nI1\naI2\naI3\na.'
>>>
>>> pickle.dumps([1,2,3], -1)
'\x80\x02]q\x00(K\x01K\x02K\x03e.'
Encore une fois, il s’agit toujours d’un dialecte de la langue de pickling et vous pouvez voir que la chaîne du protocole 0 dit "obtenez une liste, incluez I1, I2, I3", alors que le protocole 2 est plus difficile à lire, mais dit la même chose. Le premier bit \x80\x02 indique que c'est le protocole 2 - alors vous avez ] qui dit que c'est une liste, vous pouvez encore voir les entiers 1, 2, 3 ici. Encore une fois, vérifiez le code source de pickle pour voir le mappage exact de la langue de pickling.
Pour inverser le décapage en chaîne, utilisez load/load.
>>> p = pickle.dumps([1,2,3])
>>> pickle.loads(p)
[1, 2, 3]
Le pickling consiste simplement en une sérialisation: placer des données dans un formulaire pouvant être stocké dans un fichier et récupéré ultérieurement. Voici la documentation sur le module pickle:
Pickling in Python est utilisé pour sérialiser et désérialiser Python objets, comme dictionnaire dans votre cas. J'utilise habituellement cPickle module tel qu'il peut être beaucoup plus rapide que le module Pickle.
import cPickle as pickle
def serializeObject(pythonObj):
return pickle.dumps(pythonObj, pickle.HIGHEST_PROTOCOL)
def deSerializeObject(pickledObj):
return pickle.loads(pickledObj)
http://docs.python.org/library/pickle.html#example
import pickle
data1 = {'a': [1, 2.0, 3, 4+6j],
'b': ('string', u'Unicode string'),
'c': None}
selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)
output = open('data.pkl', 'wb')
# Pickle dictionary using protocol 0.
pickle.dump(data1, output)
# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)
output.close()
Le module pickle implémente un algorithme fondamental mais puissant pour la sérialisation et la désérialisation d'une structure d'objet Python. "Pickling" est le processus par lequel une hiérarchie d'objet Python est converti en un flux d'octets et "unpickling" est l'opération inverse, dans laquelle un flux d'octets est reconverti en une hiérarchie d'objets. Pickling (et unpickling) est également connu sous le nom de "sérialisation", "marshaling" ou "aplatissement". cependant, pour éviter toute confusion, les termes utilisés ici sont "décapage" et "décapage".
Le module pickle a un cousin optimisé appelé module cPickle. Comme son nom l'indique, cPickle est écrit en C, il peut donc être 1000 fois plus rapide que pickle. Cependant, il ne prend pas en charge les sous-classes des classes Pickler () et Unpickler (), car dans cPickle, ce sont des fonctions et non des classes. La plupart des applications n'ont pas besoin de cette fonctionnalité et peuvent tirer parti des performances améliorées de cPickle. En dehors de cela, les interfaces des deux modules sont presque identiques. l'interface commune est décrite dans ce manuel et des différences sont signalées le cas échéant. Dans les discussions suivantes, nous utilisons le terme "pickle" pour décrire collectivement les modules pickle et cPickle.
Les flux de données produits par les deux modules sont interchangeables.