pretty - ¿Existe un Python equivalente a Data:: Dumper de Perl?

pretty print python 3

Question

¿Hay un módulo Python que se pueda usar de la misma manera que el módulo Data::Dumper Perl?

Editar: Lo siento, debería haber sido más claro. Principalmente buscaba un módulo para inspeccionar datos en lugar de persistir.

Por cierto, gracias por las respuestas. Este es un sitio increíble!

Answer 1

Aquí hay una solución simple para volcar datos anidados formados por diccionarios, listas o tuplas (me funciona bastante bien):

def printStruct(struc, indent=0):
  if isinstance(struc, dict):
    print ''  ''*indent+''{''
    for key,val in struc.iteritems():
      if isinstance(val, (dict, list, tuple)):
        print ''  ''*(indent+1) + str(key) + ''=> ''
        printStruct(val, indent+2)
      else:
        print ''  ''*(indent+1) + str(key) + ''=> '' + str(val)
    print ''  ''*indent+''}''
  elif isinstance(struc, list):
    print ''  ''*indent + ''[''
    for item in struc:
      printStruct(item, indent+1)
    print ''  ''*indent + '']''
  elif isinstance(struc, tuple):
    print ''  ''*indent + ''(''
    for item in struc:
      printStruct(item, indent+1)
    print ''  ''*indent + '')''
  else: print ''  ''*indent + str(struc)

Véalo en el trabajo:

>>> d = [{''a1'':1, ''a2'':2, ''a3'':3}, [1,2,3], [{''b1'':1, ''b2'':2}, {''c1'':1}], ''d1'', ''d2'', ''d3'']
>>> printStruct(d)
[
  {
    a1=> 1
    a3=> 3
    a2=> 2
  }
  [
    1
    2
    3
  ]
  [
    {
      b1=> 1
      b2=> 2
    }
    {
      c1=> 1
    }
  ]
  d1
  d2
  d3
]

Answer 2

Creo que lo más cercano que encontrarás es el módulo pprint .

>>> l = [1, 2, 3, 4]
>>> l.append(l)
>>> d = {1: l, 2: ''this is a string''}
>>> print d
{1: [1, 2, 3, 4, [...]], 2: ''this is a string''}

>>> pprint.pprint(d)
{1: [1, 2, 3, 4, <Recursion on list with id=47898714920216>],
 2: ''this is a string''}

Answer 3

Data :: Dumper tiene dos usos principales: persistencia de datos y depuración / inspección de objetos. Hasta donde yo sé, no hay nada que funcione exactamente igual que Data :: Dumper.

Utilizo pickle para la persistencia de los datos.

Uso pprint para inspeccionar visualmente mis objetos / depurar.

Answer 4

En lo que respecta a la inspección de su objeto, encontré este un útil equivalente de datos: Dumper:

https://salmon-protocol.googlecode.com/svn-history/r24/trunk/salmon-playground/dumper.py

Puede manejar cadenas Unicode.

Answer 5

Necesitaba devolver el volcado similar a Perl para la solicitud de la API, así que se me ocurrió que esto no formatea la salida para que sea bonita, pero hace un trabajo perfecto para mí.

def dump(obj): if isinstance(obj, dict): return dump_dict(obj) if isinstance(obj, (list, tuple)): return dump_list(obj) else: return "''{}''".format(obj) def dump_dict(obj): result = [] for key, val in obj.items(): result.append('' => ''.join((dump(key), dump(val)))) return '' ''.join((''{'', '', ''.join(result), ''}'')) def dump_list(obj): result = [] for val in obj: result.append(dump(val)) return '' ''.join((''['', '', ''.join(result), '']''))

Usando lo anterior:

example_dict = {''a'': ''example1'', ''b'': ''example2'', ''c'': [1, 2, 3, ''asd''], ''d'': [{''g'': ''something1'', ''e'': ''something2''}, {''z'': ''something1''}]} print(dump(example_dict))

saldrá:

{ ''b'' => ''example2'', ''a'' => ''example1'', ''d'' => [ { ''g'' => ''something1'', ''e'' => ''something2'' }, { ''z'' => ''something1'' } ], ''c'' => [ ''1'', ''2'', ''3'', ''asd'' ] }

Answer 6

Posiblemente un par de alternativas: pickle , marshal , shelve .

Answer 7

Yo también he estado usando Data :: Dumper por bastante tiempo y me he acostumbrado a su forma de mostrar estructuras de datos complejas con un buen formato. pprint como se mencionó anteriormente hace un trabajo bastante decente, pero no me gustó su estilo de formateo. Esa característica más no le permite inspeccionar objetos como Data :: Dumper:

Buscó en la red y encontró estos:

https://gist.github.com/1071857#file_dumper.pyamazon

>>> y = { 1: [1,2,3], 2: [{''a'':1},{''b'':2}]}

>>> pp = pprint.PrettyPrinter(indent = 4)
>>> pp.pprint(y)
{   1: [1, 2, 3], 2: [{   ''a'': 1}, {   ''b'': 2}]}

>>> print(Dumper.dump(y)) # Dumper is the python module in the above link

{ 1: [ 1 2 3 ] 2: [ { ''a'': 1 } { ''b'': 2 } ] }

>>> print(Dumper.dump(pp))

instance::pprint.PrettyPrinter __dict__ :: { ''_depth'': None ''_stream'': file:: > ''_width'': 80 ''_indent_per_level'': 4 }

También vale la pena consultar http://salmon-protocol.googlecode.com/svn-history/r24/trunk/salmon-playground/dumper.py Tiene su propio estilo y parece útil también.

Answer 8

• Para la serialización, hay muchas opciones.

  • Uno de los mejores es JSON, que es un estándar independiente del idioma para la serialización. Está disponible en 2.6 en el módulo stdlib json y antes con la misma API en el módulo simplejson terceros.

  • No quiere usar marshal , que es bastante bajo nivel. Si quería lo que ofrece, usaría pickle.

  • Evito usar Pickle, el formato es solo de Python e inseguro. La deserialización usando pickle puede ejecutar código arbitrario.

    • Si usó pickle , quiere usar la implementación C de la misma. ( import cPickle as pickle ).

• Para la depuración, por lo general, desea ver la representación del objeto o utilizar el módulo pprint .