Comment puis-je utiliser des cornichons pour enregistrer un dict?

J'ai parcouru les informations fournies par les documents Python , mais je suis toujours un peu confus. Quelqu'un pourrait-il publier un exemple de code qui écrirait un nouveau fichier, puis utiliser pickle pour y vider 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 HIGHEST_PROTOCOLest que les fichiers deviennent plus petits. Cela rend le décapage parfois beaucoup plus rapide.

Remarque importante : La taille maximale du fichier de cornichon est d'environ 2 Go.

Voie 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: agréable pour écrire des données lisibles par l'homme; TRÈS couramment utilisé ( lecture et écriture )
• YAML: YAML est un sur-ensemble de JSON, mais plus facile à lire ( lecture et écriture , comparaison de JSON et YAML )
• pickle: format de sérialisation Python ( lecture et écriture )
• MessagePack ( package Python ): représentation plus compacte ( lecture et écriture )
• HDF5 ( package Python ): idéal pour les matrices ( lecture et écriture )
• XML: existe aussi * soupir * ( lire & écriture )

Pour votre application, les éléments suivants peuvent être importants:

• Prise en charge par d'autres langages de programmation
• Lecture / écriture
• Compacité (taille du fichier)

Voir aussi: Comparaison des formats de sérialisation des données

Dans le cas où vous cherchez plutôt un moyen de créer des fichiers de configuration, vous voudrez peut-être 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, le décapage d'un dictéchouera sauf si vous n'avez que des objets simples, comme 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 très simple dictéchouera souvent. Cela dépend simplement 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 comme dillou cloudpickle, la plupart des dictionnaires peuvent être décapés:

>>> import dill
>>> pik = dill.dumps(d)

Ou si vous souhaitez enregistrer votre dictfichier dans un fichier ...

>>> with open('save.pik', 'w') as f:
...   dill.dump(globals(), f)
... 

Ce dernier exemple est identique à toutes les autres bonnes réponses publiées ici (qui, en plus de négliger la picklabilité du contenu du, dictsont 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.

Si vous voulez simplement stocker le dict dans un seul fichier, utilisez picklecomme ç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 le reste dont vous avez besoinpickle

from anycache import anycache

@anycache(cachedir='path/to/files')
def myfunc(hello):
    return {'hello', hello}

Anycache stocke les différents myfuncrésultats en fonction des arguments des différents fichiers cachediret les recharge.

Voir la documentation pour plus de détails.

Un moyen simple de vider 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'))

import pickle

dictobj = {'Jack' : 123, 'John' : 456}

filename = "/foldername/filestore"

fileobj = open(filename, 'wb')

pickle.dump(dictobj, fileobj)

fileobj.close()

J'ai trouvé le décapage déroutant (peut-être parce que je suis épais). J'ai trouvé que cela fonctionne, cependant:

myDictionaryString=str(myDictionary)

Que vous pouvez ensuite écrire dans un fichier texte. J'ai renoncé à utiliser des cornichons car je recevais des erreurs me disant d'écrire des entiers dans un fichier .dat. Je m'excuse de ne pas avoir utilisé de cornichons.