Comment puis-je utiliser pickle pour enregistrer un dict?
J'ai regardé à travers les informations que Docs Python , mais je suis toujours un peu confus. Quelqu'un pourrait-il poster un exemple de code permettant d'écrire un nouveau fichier, puis utiliser pickle pour y déposer un dictionnaire?
Essaye ça:
import pickle
a = {'hello': 'world'}
with open('filename.pickle', 'wb') as handle:
pickle.dump(a, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open('filename.pickle', 'rb') as handle:
b = pickle.load(handle)
print a == b
import pickle
your_data = {'foo': 'bar'}
# Store data (serialize)
with open('filename.pickle', 'wb') as handle:
pickle.dump(your_data, handle, protocol=pickle.HIGHEST_PROTOCOL)
# Load data (deserialize)
with open('filename.pickle', 'rb') as handle:
unserialized_data = pickle.load(handle)
print(your_data == unserialized_data)
L'avantage de HIGHEST_PROTOCOL est que les fichiers deviennent plus petits. Cela accélère parfois le dépouillement.
Remarque importante : La taille maximale du fichier de pickle est d'environ 2 Go.
Manière alternative
import mpu
your_data = {'foo': 'bar'}
mpu.io.write('filename.pickle', data)
unserialized_data = mpu.io.read('filename.pickle')
Formats alternatifs
- CSV: format super simple ( lecture et écriture )
- JSON: Idéal pour écrire des données lisibles par l'homme. TRÈS couramment utilisé ( lire et écrire )
- YAML: YAML est un sur-ensemble de JSON, mais plus facile à lire ( lire & écrire , comparaison de JSON et de YAML )
- pickle: Un format de sérialisation Python _ ( lecture & écriture )
- MessagePack ( paquet Python ): Représentation plus compacte ( lecture et écriture )
- HDF5 ( paquet Python ): sympa pour les matrices ( lecture & écriture )
- XML: existe aussi * soupir * ( lire & écrire )
Pour votre application, les éléments suivants peuvent être importants:
- Prise en charge par d'autres langages de programmation
- Lecture/écriture
- Compacité (taille de fichier)
Voir aussi: Comparaison des formats de sérialisation des données
Si vous cherchez plutôt un moyen de créer des fichiers de configuration, vous pouvez lire mon court article Fichiers de configuration en Python
# Save a dictionary into a pickle file.
import pickle
favorite_color = {"lion": "yellow", "kitty": "red"} # create a dictionary
pickle.dump(favorite_color, open("save.p", "wb")) # save it into a file named save.p
# -------------------------------------------------------------
# Load the dictionary back from the pickle file.
import pickle
favorite_color = pickle.load(open("save.p", "rb"))
# favorite_color is now {"lion": "yellow", "kitty": "red"}
En général, la sélection d'une dict échouera à moins que vous ne disposiez que de simples objets, tels que des chaînes et des entiers.
Python 2.7.9 (default, Dec 11 2014, 01:21:43)
[GCC 4.2.1 Compatible Apple Clang 4.1 ((tags/Apple/clang-421.11.66))] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> from numpy import *
>>> type(globals())
<type 'dict'>
>>> import pickle
>>> pik = pickle.dumps(globals())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 1374, in dumps
Pickler(file, protocol).dump(obj)
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 224, in dump
self.save(obj)
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 286, in save
f(self, obj) # Call unbound method with explicit self
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 649, in save_dict
self._batch_setitems(obj.iteritems())
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 663, in _batch_setitems
save(v)
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 306, in save
rv = reduce(self.proto)
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/copy_reg.py", line 70, in _reduce_ex
raise TypeError, "can't pickle %s objects" % base.__name__
TypeError: can't pickle module objects
>>>
Même un vraiment simple dict échouera souvent. Cela dépend du contenu.
>>> d = {'x': lambda x:x}
>>> pik = pickle.dumps(d)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 1374, in dumps
Pickler(file, protocol).dump(obj)
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 224, in dump
self.save(obj)
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 286, in save
f(self, obj) # Call unbound method with explicit self
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 649, in save_dict
self._batch_setitems(obj.iteritems())
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 663, in _batch_setitems
save(v)
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 286, in save
f(self, obj) # Call unbound method with explicit self
File "/opt/local/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/pickle.py", line 748, in save_global
(obj, module, name))
pickle.PicklingError: Can't pickle <function <lambda> at 0x102178668>: it's not found as __main__.<lambda>
Cependant, si vous utilisez un meilleur sérialiseur tel que dill ou cloudpickle, alors la plupart des dictionnaires peuvent être conservés:
>>> import dill
>>> pik = dill.dumps(d)
Ou si vous voulez enregistrer votre dict dans un fichier ...
>>> with open('save.pik', 'w') as f:
... dill.dump(globals(), f)
...
Ce dernier exemple est identique à l’une des autres bonnes réponses publiées ici (qui, outre le fait de négliger la faculté de choisir le contenu de la dict sont bonnes).
>>> import pickle
>>> with open("/tmp/picklefile", "wb") as f:
... pickle.dump({}, f)
...
normalement, il est préférable d'utiliser l'implémentation cPickle
>>> import cPickle as pickle
>>> help(pickle.dump)
Help on built-in function dump in module cPickle:
dump(...)
dump(obj, file, protocol=0) -- Write an object in pickle format to the given file.
See the Pickler docstring for the meaning of optional argument proto.
Un moyen simple de transférer une donnée Python (par exemple, un dictionnaire) dans un fichier pickle.
import pickle
your_dictionary = {}
pickle.dump(your_dictionary, open('pickle_file_name.p', 'wb'))
Si vous voulez juste stocker le dict dans un seul fichier, utilisez pickle comme ça
import pickle
a = {'hello': 'world'}
with open('filename.pickle', 'wb') as handle:
pickle.dump(a, handle)
with open('filename.pickle', 'rb') as handle:
b = pickle.load(handle)
Si vous souhaitez enregistrer et restaurer plusieurs dictionnaires dans plusieurs fichiers pour la mise en cache et stocker des données plus complexes, utilisez anycache . Il fait tout ce dont vous avez besoin autour de pickle
from anycache import anycache
@anycache(cachedir='path/to/files')
def myfunc(hello):
return {'hello', hello}
Anycache stocke les différents résultats myfunc en fonction des arguments de différents fichiers dans cachedir et les recharge.
Voir le documentation pour plus de détails.
import pickle
dictobj = {'Jack' : 123, 'John' : 456}
filename = "/foldername/filestore"
fileobj = open(filename, 'wb')
pickle.dump(dictobj, fileobj)
fileobj.close()