Есть ли Python эквивалентный Perl Data :: Dumper?

Question

Существует ли модуль Python, который можно использовать так же, как модуль Perl Data::Dumper?

Редактировать: Извините, мне следовало быть яснее. Я был в основном после модуля для проверки данных, а не сохранения.

Кстати, спасибо за ответы. Это один удивительный сайт!

Answer 1

Data :: Dumper имеет два основных назначения: сохранение данных и отладка / проверка объектов. Насколько я знаю, нет ничего, что будет работать точно так же, как Data :: Dumper.

Я использую рассол для сохранения данных.

Я использую pprint для визуальной проверки моих объектов / отладки.

Answer 2

Я думаю, что ближе всего вы найдете модуль 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

Возможно пара альтернатив: рассол , маршал , полка .

Answer 4

Вот простое решение для вывода вложенных данных, составленных из словарей, списков или кортежей (у меня это работает довольно хорошо):

python2

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)

Python3

 def printStruct(struc, indent=0):
   if isinstance(struc, dict):
     print ('  '*indent+'{')
     for key,val in struc.items():
       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))

Посмотри на работу:

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

• Для сериализации существует множество опций.

  • Одним из лучших является JSON, не зависящий от языка стандарт для сериализации. Он доступен в версии 2.6 в модуле stdlib json и до этого с тем же API в стороннем модуле simplejson.

  • Вы не хотите использовать marshal, который является довольно низким уровнем. Если вы хотели получить то, что он предоставляет, вы бы использовали маринад.

  • Я избегаю использования pickle, так как формат только для Python и небезопасен. Десериализация с использованием pickle может выполнить произвольный код.

    • Если вы использовали pickle, вы хотите использовать его реализацию на C. (Do import cPickle as pickle.)

• Для отладки обычно требуется посмотреть на repr объекта или использовать модуль pprint.

Answer 6

Я тоже давно использую Data :: Dumper и привык к способу отображения красиво отформатированных сложных структур данных. Как упоминалось выше, pprint выполняет довольно приличную работу, но мне не очень понравился его стиль форматирования. Этот плюс pprint не позволяет вам проверять объекты, как Data :: Dumper:

Искал в сети и наткнулся на эти:

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
    }

Также стоит проверить это http://salmon -protocol.googlecode.com / svn-history / r24 / trunk / salmon-plays / dumper.py Он имеет свой собственный стиль и, кажется, тоже полезен.

Answer 7

Если вы хотите что-то, что работает лучше, чем pprint, но не требует прокрутки, попробуйте импортировать дампер из pypi:
https://github.com/jric/Dumper.py или https://github.com/ericholscher/pypi/blob/master/dumper.py

Answer 8

Что касается проверки вашего объекта, я нашел этот полезный эквивалент Data: Dumper:

https://salmon -protocol.googlecode.com / СВН-история / r24 / багажник / лососевая площадка / dumper.py

Может обрабатывать строки Unicode.

Answer 9

Мне нужно было возвращать Perl-подобный дамп для запроса API, поэтому я придумал это, которое не форматирует вывод, чтобы быть симпатичным, но делает идеальную работу для меня.

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