¿Cómo puedo usar pickle para guardar un dict?

He revisado la información que proporcionan los documentos de Python , pero todavía estoy un poco confundido. ¿Alguien podría publicar un código de muestra que escribiría un nuevo archivo y luego usar pickle para volcar un diccionario en él?

Prueba esto:

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)

La ventaja de HIGHEST_PROTOCOLes que los archivos se hacen más pequeños. Esto hace que el desempaquetado sea a veces mucho más rápido.

Aviso importante : el tamaño máximo de archivo de pickle es de aproximadamente 2 GB.

Forma alternativa

import mpu
your_data = {'foo': 'bar'}
mpu.io.write('filename.pickle', data)
unserialized_data = mpu.io.read('filename.pickle')

Formatos alternativos

• CSV: formato súper simple ( lectura y escritura )
• JSON: Agradable para escribir datos legibles por humanos; MUY comúnmente utilizado ( leer y escribir )
• YAML: YAML es un superconjunto de JSON, pero más fácil de leer ( leer y escribir , comparación de JSON y YAML )
• pickle: un formato de serialización de Python ( lectura y escritura )
• MessagePack ( paquete Python ): representación más compacta ( lectura y escritura )
• HDF5 ( paquete Python ): agradable para matrices ( lectura y escritura )
• XML: existe también * suspiro * ( lectura y escritura )

Para su aplicación, lo siguiente puede ser importante:

• Soporte por otros lenguajes de programación.
• Rendimiento de lectura / escritura
• Compacidad (tamaño del archivo)

Ver también: Comparación de formatos de serialización de datos.

En caso de que esté buscando una manera de crear archivos de configuración, puede leer mi breve artículo Archivos de configuración 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 general, el decapado dictfallará a menos que solo tenga objetos simples, como cadenas y enteros.

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
>>> 

Incluso un muy simple dicta menudo fallará. Solo depende de los contenidos.

>>> 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>

Sin embargo, si usa un mejor serializador como dillo cloudpickle, entonces la mayoría de los diccionarios se pueden encurtir:

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

O si desea guardar su dicten un archivo ...

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

El último ejemplo es idéntico a cualquiera de las otras buenas respuestas publicadas aquí (que además de descuidar la capacidad de selección de los contenidos de la dictson buenas).

>>> import pickle
>>> with open("/tmp/picklefile", "wb") as f:
...     pickle.dump({}, f)
... 

normalmente es preferible usar la implementación de 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 solo desea almacenar el dict en un solo archivo, use pickleasí

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 desea guardar y restaurar múltiples diccionarios en múltiples archivos para almacenar en caché y almacenar datos más complejos, use anycache . Hace todas las otras cosas que necesitas alrededorpickle

from anycache import anycache

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

Anycache almacena los diferentes myfuncresultados según los argumentos de los diferentes archivos cachediry los vuelve a cargar.

Consulte la documentación para más detalles.

Manera simple de volcar datos de Python (por ejemplo, diccionario) en un archivo 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()

Encontré el encurtido confuso (posiblemente porque soy grueso). Sin embargo, descubrí que esto funciona:

myDictionaryString=str(myDictionary)

Que luego puede escribir en un archivo de texto. Dejé de intentar usar pickle porque recibía errores que me decían que escribiera enteros en un archivo .dat. Pido disculpas por no usar pepinillo.