serialización - serializacion de objetos python

Serialización de objetos legibles por humanos Python

Question

Necesito almacenar las estructuras de Python hechas de listas / diccionarios, tuplas en un formato legible para humanos. La idea es como usar algo similar a pickle , pero pickle no es amigable para los humanos. Otras opciones que me vienen a la mente son YAML (a través de los serializadores PyYAML y JSON (a través de simplejson ).

¿Alguna otra opción que se te ocurra?

Gracias por adelantado.

Answer 1

Para casos simples vienen a la mente pprint () y eval ().

Usando tu ejemplo:

>>> d = {''age'': 27,
...  ''name'': ''Joe'',
...  ''numbers'': [1, 
...              2, 
...              3,
...              4,
...              5],
...  ''subdict'': {
...              ''first'': 1, 
...              ''second'': 2,
...               ''third'': 3
...              }
... }
>>> 
>>> from pprint import pprint
>>> pprint(d)
{''age'': 27,
 ''name'': ''Joe'',
 ''numbers'': [1, 2, 3, 4, 5],
 ''subdict'': {''first'': 1, ''second'': 2, ''third'': 3}}
>>> 

Lo pensaría dos veces antes de arreglar dos requisitos con la misma herramienta. ¿Ha considerado usar pickle para la serialización y luego pprint () (o un visor de objetos más sofisticado) para los humanos que miran los objetos?

Answer 2

Para usar simplejson primero easy_install simplejson :

import simplejson
my_structure = {"name":"Joe", "age":27, "numbers":[1,2,3,4,5], "subdict":{"first":1, "second":2, "third": 3}}
json = simplejson.dumps(my_structure)

resultados en json siendo:

{"age": 27, "subdict": {"second": 2, "third": 3, "first": 1}, "name": "Joe", "numbers": [1, 2, 3, 4, 5]}

Tenga en cuenta que apenas cambia el formato del diccionario, pero debe ejecutarlo a través de este paso para garantizar datos JSON válidos.

Puedes imprimir mejor el resultado:

import pprint
pprint.pprint(my_structure)

resultados en:

{''age'': 27,
 ''name'': ''Joe'',
 ''numbers'': [1, 2, 3, 4, 5],
 ''subdict'': {''first'': 1, ''second'': 2, ''third'': 3}}

Answer 3

Si es solo una lista de Python, un diccionario y un objeto de tupla. - JSON es el camino a seguir. Es legible por humanos, muy fácil de manejar y también independiente del lenguaje.

Precaución: las tuplas se convertirán a listas en simplejson.

In [109]: simplejson.loads(simplejson.dumps({''d'':(12,3,4,4,5)}))
Out[109]: {u''d'': [12, 3, 4, 4, 5]}

Answer 4

Si buscas más representaciones que las cubiertas por JSON, te recomiendo que revises PyON (Notación de Objetos Python) ... aunque creo que está restringido a 2.6 / 3.0 y superior, ya que depende del módulo ast . Maneja instancias de clases personalizadas y tipos de datos recursivos, entre otras características, que es más de lo que proporciona JSON.

Answer 5

Debería consultar jsonpickle ( http://code.google.com/p/jsonpickle/ ). Escribirá cualquier objeto python en un archivo json. A continuación, puede volver a leer ese archivo en un objeto Python. Lo bueno es que el archivo intermedio es muy legible porque es json.

Answer 6

¿Qué quieres decir con que esto no es legible por los humanos? ;)

>>> d = {''age'': 27, 
...   ''name'': ''Joe'',
...   ''numbers'': [1,2,3,4,5],
...   ''subdict'': {''first'':1, ''second'':2, ''third'':3}
... }
>>> 
>>> import pickle
>>> p = pickle.dumps(d)      
>>> p
"(dp0/nS''age''/np1/nI27/nsS''subdict''/np2/n(dp3/nS''second''/np4/nI2/nsS''third''/np5/nI3/nsS''first''/np6/nI1/nssS''name''/np7/nS''Joe''/np8/nsS''numbers''/np9/n(lp10/nI1/naI2/naI3/naI4/naI5/nas."

Ok, bueno, tal vez solo requiere algo de práctica ... o podrías hacer trampa ...

>>> import pickletools 
>>> pickletools.dis(p)
    0: (    MARK
    1: d        DICT       (MARK at 0)
    2: p    PUT        0
    5: S    STRING     ''age''
   12: p    PUT        1
   15: I    INT        27
   19: s    SETITEM
   20: S    STRING     ''subdict''
   31: p    PUT        2
   34: (    MARK
   35: d        DICT       (MARK at 34)
   36: p    PUT        3
   39: S    STRING     ''second''
   49: p    PUT        4
   52: I    INT        2
   55: s    SETITEM
   56: S    STRING     ''third''
   65: p    PUT        5
   68: I    INT        3
   71: s    SETITEM
   72: S    STRING     ''first''
   81: p    PUT        6
   84: I    INT        1
   87: s    SETITEM
   88: s    SETITEM
   89: S    STRING     ''name''
   97: p    PUT        7
  100: S    STRING     ''Joe''
  107: p    PUT        8
  110: s    SETITEM
  111: S    STRING     ''numbers''
  122: p    PUT        9
  125: (    MARK
  126: l        LIST       (MARK at 125)
  127: p    PUT        10
  131: I    INT        1
  134: a    APPEND
  135: I    INT        2
  138: a    APPEND
  139: I    INT        3
  142: a    APPEND
  143: I    INT        4
  146: a    APPEND
  147: I    INT        5
  150: a    APPEND
  151: s    SETITEM
  152: .    STOP
highest protocol among opcodes = 0
>>> 

Todavía tendría que leer el objeto escabechado de un archivo, sin embargo, no necesitaría load . Por lo tanto, si se trata de un objeto "peligroso", es posible que aún puedas descifrarlo antes de realizar la load . Si está atascado con un pickle , podría ser una buena opción para descifrar lo que tiene.

Answer 7

Hay un formato AXON (textual) que combina lo mejor de JSON, XML y YAML. El formato AXON es bastante legible y relativamente compacto.

El pyaxon del módulo python (2.7 / 3.3 / 3.4) admite la funcionalidad de load(s) / dump(s) , incluida la loading / dumping iterativa. Es lo suficientemente rápido para ser útil.

Considera un ejemplo simple:

>>> d = {
     ''age'': 27, ''name'': ''Joe'', 
     ''numbers'': [1, 2, 3, 4, 5], 
     ''subdict'': {''first'': 1, ''second'': 2, ''third'': 3}
    }
# pretty form
>>> axon.dumps(d, pretty=1)
{ age: 27
  name: "Joe"
  numbers: [1 2 3 4 5]
  subdict: {
    first: 1
    second: 2
    third: 3}}
# compact form
>>> axon.dumps(d)
{age:27 name:"Joe" numbers:[1 2 3 4 5] subdict:{first:1 second:2 third:3}}

También puede manejar múltiples objetos en el mensaje:

>>> msg = axon.dumps([{''a'':1, ''b'':2, ''c'':3}, {''a'':2, ''b'':3, ''c'':4}])
>>> print(msg)
{a:1 b:2 c:3} 
{a:2 b:3 c:4}
{a:3 b:4 c:5}

y luego cargarlos iterativamente:

for d in axon.iloads(msg):
   print(d)