Y a-t-il un Python équivalent aux données de Perl::Dumper?

peut-être un couple de solutions de rechange: cornichon , maréchal , en suspens .

je pense que le plus proche que vous trouverez est le module 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'}

• pour la sérialisation, il y a plusieurs options.

  • L'un des meilleurs est JSON, qui est un langage agnostique standard pour la sérialisation. Il est disponible en 2.6 dans le module stdlib json et avant cela avec la même API dans le module tiers simplejson .

  • Vous ne voulez pas utiliser marshal , ce qui est assez de bas niveau. Si vous vouliez ce qu'il fournit, vous utiliseriez cornichon.

  • j'évite d'utiliser pickle le format est Python seul et non sécurisé. La désérialisation à l'aide de pickle peut exécuter du code arbitraire.

    • si vous avez utilisé pickle , vous voulez utiliser l'implémentation C. (Do import cPickle as pickle .)

• pour le débogage, vous vous voulez regarder le repr de l'objet ou utiliser le module pprint .

Voici une solution simple pour déverser des données imbriquées composées de dictionnaires, de listes ou de tuples (cela fonctionne assez bien pour moi):

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)

voir au travail:

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

moi aussi j'utilise Data::Dumper depuis un certain temps et je me suis habitué à sa façon d'Afficher des structures de données complexes bien formatées. pprint comme mentionné ci-dessus fait un travail assez décent, mais je n'ai pas tout à fait aimé son style de formatage. Cela plus pprint ne vous permet pas d'inspecter des objets comme Data:: Dumper fait:

a cherché sur le net et est tombé sur ceux-ci:

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
    }

aussi à vérifier est http://salmon-protocol.googlecode.com/svn-history/r24/trunk/salmon-playground/dumper.py il a son propre style et semble utile aussi.

en ce qui concerne l'inspection de votre objet va, j'ai trouvé cela un équivalent utile de données: Dumper:

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

il peut gérer les chaînes unicode.

j'avais besoin de retourner un dump Perl-like pour une requête API, donc j'ai trouvé ceci qui ne formate pas la sortie pour être joli, mais fait un travail parfait pour moi.

from decimal import Decimal
from datetime import datetime, date

def dump(self, obj):

    if obj is None:
        return "undef"

    if isinstance(obj, dict):
        return self.dump_dict(obj)

    if isinstance(obj, (list, tuple)):
        return self.dump_list(obj)

    if isinstance(obj, Decimal):
        return "'{:.05f}'".format(obj)
        # ... or handle it your way

    if isinstance(obj, (datetime, date)):
        return "'{}'".format(obj.isoformat(
            sep=' ',
            timespec='milliseconds'))
        # ... or handle it your way

    return "'{}'".format(obj)

def dump_dict(self, obj):
    result = []
    for key, val in obj.items():
        result.append(' => '.join((self.dump(key), self.dump(val))))

    return ' '.join(('{', ', '.join(result), '}'))

def dump_list(self, obj):
    result = []
    for val in obj:
        result.append(self.dump(val))

    return ' '.join(('[', ', '.join(result), ']'))



Using the above:

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

    print(dump(example_dict))

will ouput:

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