Pickle o json?

Necesito guardar en el disco un pequeño dictobjeto cuyas claves son del tipo stry los valores son intsy luego recuperarlo . Algo como esto:

{'juanjo': 2, 'pedro':99, 'other': 333}

¿Cuál es la mejor opción y por qué? ¿Serializarlo con pickleo con simplejson?

Estoy usando Python 2.6.

Si no tiene ningún requisito de interoperabilidad (por ejemplo, solo va a usar los datos con Python) y un formato binario está bien, vaya con cPickle, que le brinda una serialización de objetos Python realmente rápida.

Si desea interoperabilidad o desea un formato de texto para almacenar sus datos, vaya con JSON (o algún otro formato apropiado según sus limitaciones).

Prefiero JSON sobre pickle para mi serialización. Unpickling puede ejecutar código arbitrario y usarlo picklepara transferir datos entre programas o almacenar datos entre sesiones es un agujero de seguridad. JSON no introduce un agujero de seguridad y está estandarizado, por lo que los programas en diferentes idiomas pueden acceder a los datos si alguna vez lo necesita.

También puede encontrar esto interesante, con algunos gráficos para comparar: http://kovshenin.com/archives/pickle-vs-json-which-is-faster/

Si lo que más le preocupa es la velocidad y el espacio, use cPickle porque cPickle es más rápido que JSON.

Si está más preocupado por la interoperabilidad, la seguridad y / o la legibilidad humana, utilice JSON.

Los resultados de las pruebas a los que se hace referencia en otras respuestas se registraron en 2010, y las pruebas actualizadas en 2016 con el protocolo cPickle 2 muestran:

• cPickle carga 3.8 veces más rápida
• cPickle lectura 1,5 veces más rápida
• cPickle codificación ligeramente más pequeña

Reproduzca esto usted mismo con esta esencia , que se basa en el punto de referencia de Konstantin al que se hace referencia en otras respuestas, pero usando cPickle con el protocolo 2 en lugar de pickle, y usando json en lugar de simplejson (ya que json es más rápido que simplejson ), por ejemplo

wget https://gist.github.com/jdimatteo/af317ef24ccf1b3fa91f4399902bb534/raw/03e8dbab11b5605bc572bc117c8ac34cfa959a70/pickle_vs_json.py
python pickle_vs_json.py

Resultados con python 2.7 en un procesador Xeon 2015 decente:

Dir Entries Method  Time    Length

dump    10  JSON    0.017   1484510
load    10  JSON    0.375   -
dump    10  Pickle  0.011   1428790
load    10  Pickle  0.098   -
dump    20  JSON    0.036   2969020
load    20  JSON    1.498   -
dump    20  Pickle  0.022   2857580
load    20  Pickle  0.394   -
dump    50  JSON    0.079   7422550
load    50  JSON    9.485   -
dump    50  Pickle  0.055   7143950
load    50  Pickle  2.518   -
dump    100 JSON    0.165   14845100
load    100 JSON    37.730  -
dump    100 Pickle  0.107   14287900
load    100 Pickle  9.907   -

Python 3.4 con el protocolo pickle 3 es aún más rápido.

JSON o pepinillo? ¿Qué tal JSON y pickle? Puede utilizar jsonpickle. Es fácil de usar y el archivo en el disco se puede leer porque es JSON.

http://jsonpickle.github.com/

Probé varios métodos y descubrí que usar cPickle con la configuración del argumento de protocolo del método de volcados como: cPickle.dumps(obj, protocol=cPickle.HIGHEST_PROTOCOL)es el método de volcado más rápido.

import msgpack
import json
import pickle
import timeit
import cPickle
import numpy as np

num_tests = 10

obj = np.random.normal(0.5, 1, [240, 320, 3])

command = 'pickle.dumps(obj)'
setup = 'from __main__ import pickle, obj'
result = timeit.timeit(command, setup=setup, number=num_tests)
print("pickle:  %f seconds" % result)

command = 'cPickle.dumps(obj)'
setup = 'from __main__ import cPickle, obj'
result = timeit.timeit(command, setup=setup, number=num_tests)
print("cPickle:   %f seconds" % result)


command = 'cPickle.dumps(obj, protocol=cPickle.HIGHEST_PROTOCOL)'
setup = 'from __main__ import cPickle, obj'
result = timeit.timeit(command, setup=setup, number=num_tests)
print("cPickle highest:   %f seconds" % result)

command = 'json.dumps(obj.tolist())'
setup = 'from __main__ import json, obj'
result = timeit.timeit(command, setup=setup, number=num_tests)
print("json:   %f seconds" % result)


command = 'msgpack.packb(obj.tolist())'
setup = 'from __main__ import msgpack, obj'
result = timeit.timeit(command, setup=setup, number=num_tests)
print("msgpack:   %f seconds" % result)

Salida:

pickle         :   0.847938 seconds
cPickle        :   0.810384 seconds
cPickle highest:   0.004283 seconds
json           :   1.769215 seconds
msgpack        :   0.270886 seconds

Personalmente, generalmente prefiero JSON porque los datos son legibles por humanos . Definitivamente, si necesita serializar algo que JSON no aceptará, use pickle.

Pero para la mayoría del almacenamiento de datos, no necesitará serializar nada extraño y JSON es mucho más fácil y siempre le permite abrirlo en un editor de texto y verificar los datos usted mismo.

La velocidad es buena, pero para la mayoría de los conjuntos de datos la diferencia es insignificante; Python generalmente no es demasiado rápido de todos modos.