webentwicklung-frage-antwort-db.com.de

Gibt es ein Python-Äquivalent zu Perls Data :: Dumper?

Gibt es ein Python-Modul, das genauso verwendet werden kann wie das Perl-Modul Data::Dumper ?

Edit: Sorry, ich hätte klarer sein sollen. Ich war hauptsächlich nach einem Modul zum Untersuchen von Daten, anstatt zu bestehen.

BTW Danke für die Antworten. Dies ist eine großartige Seite!

35
Rob Wells

Data :: Dumper hat zwei Hauptanwendungen: Datenpersistenz und Debugging/Inspection-Objekte. Soweit ich weiß, gibt es nichts, was genau wie Data :: Dumper funktioniert.

Ich benutze pickle für Datenpersistenz.

Ich benutze pprint , um meine Objekte visuell zu prüfen/zu debuggen.

28
jjfine

Möglicherweise ein paar Alternativen: Gurke , Marschall , Shelve .

4

Ich denke, am nächsten finden Sie das Modul 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'}
4
JimB
  • Für die Serialisierung gibt es viele Optionen. 

    • Eines der besten ist JSON, ein sprachenunabhängiger Standard für die Serialisierung. Es ist in 2.6 im Modul stdlib json und davor mit derselben API im Fremdmodul simplejson verfügbar. 

    • Sie möchten marshal nicht verwenden, was ziemlich niedrig ist. Wenn Sie wollten, was es bietet, würden Sie Pickle verwenden.

    • Ich vermeide die Verwendung von Pickle, das Format ist nur Python und unsicher. Durch die Deserialisierung mit Pickle kann ein beliebiger Code ausgeführt werden.

      • Wenn Sie pickle verwendet haben, möchten Sie die C-Implementierung davon verwenden. (Do import cPickle as pickle.)
  • Für das Debuggen möchten Sie normalerweise die repr des Objekts betrachten oder das pprint-Modul verwenden.

3
Mike Graham

Hier ist eine einfache Lösung zum Speichern geschachtelter Daten, die aus Wörterbüchern, Listen oder Tupeln bestehen (dies funktioniert ganz gut für mich):

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)

Sehen Sie es bei der Arbeit:

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

Auch ich benutze Data :: Dumper seit geraumer Zeit und habe mich daran gewöhnt, schön formatierte komplexe Datenstrukturen darzustellen. pprint ist, wie oben erwähnt, ziemlich anständig, aber der Formatierungsstil gefiel mir nicht. Dieses Plus von pprint erlaubt es Ihnen nicht, Objekte wie Data :: Dumper zu untersuchen:

Im Internet gesucht und auf diese gestoßen:

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))
 Instanz :: pprint.PrettyPrinter 
 __dict__ :: {
 '_depth': Keine 
 '_stream': file ::> 
 '_width ': 80 
' _Indent_per_level ': 4 
} 

Es lohnt sich auch zu überprüfen: http://salmon-protocol.googlecode.com/svn-history/r24/trunk/salmon-playground/dumper.py Es hat seinen eigenen Stil und scheint auch nützlich zu sein.

2
Saurabh Hirani

Was das Überprüfen Ihres Objekts betrifft, fand ich dies als nützliches Äquivalent zu Data: Dumper:

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

Es kann Unicode-Strings verarbeiten.

1
Damon

Wenn Sie etwas möchten, das besser funktioniert als pprint, aber kein Rollen Ihres eigenen erforderlich ist, versuchen Sie, den Dumper von pypi zu importieren:
https://github.com/jric/Dumper.py oder https://github.com/ericholscher/pypi/blob/master/dumper.py

1

Sah dies und erkannte Python hat etwas, das ähnlich wie Data :: Dumper in Dumper funktioniert. Der Autor beschreibt es als

Dump Python Datenstrukturen (einschließlich Klasseninstanzen) in einer gut verschachtelten, einfach zu lesenden Form. Behandelt rekursive Datenstrukturen ordnungsgemäß und verfügt über sinnvolle Optionen, um das Ausmaß des Dumps zu begrenzen einfache Tiefe und durch einige Regeln für den Umgang mit enthaltenen Instanzen.

Installieren Sie es über Pip. Das Github-Repo befindet sich unter https://github.com/jric/Dumper.py .

0
sevenr

Ich musste einen perl-artigen Dump für die API-Anforderung zurückgeben. Daher kam ich zu dem Ergebnis, bei dem die Ausgabe nicht schön formatiert wird, sondern der perfekte Job für mich ist.

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' ] }
0
Mario Kirov