Python Menschen lesbare Objektserialisierung

Question

ich brauche Python Strukturen zu speichern aus Listen / Wörterbücher, Tupeln in ein für Menschen lesbares Format. Die Idee ist, wie mit etwas Ähnliches wie Gurke , aber Gurke ist nicht menschenfreundlich. Andere Optionen, die mir in den Sinn kommen, sind YAML (durch PyYAML und JSON (durch simplejson ) Serializer.

Jede andere Option, die in den Sinn kommt?

Vielen Dank im Voraus.

Answer 1

Für einfache Fälle pprint () und eval () in den Sinn kommen.

Mit Ihrem Beispiel:

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

Ich würde denken, zweimal über zwei Anforderungen mit dem gleichen Werkzeug zu befestigen. Haben Sie darüber nachgedacht für die Serialisierung mit Gurke und dann pprint () (oder mehr Phantasie Objekt-Viewer) für die Gegenstände suchen Menschen?

Answer 2

Wenn sein nur Python-Liste, Wörterbuch und Tupel-Objekt. - JSON ist der Weg zu gehen. Seine Menschen lesbar, sehr einfach unabhängig zu handhaben und Sprache.

. Achtung: Tupeln wird auf Listen in simplejson umgewandelt werden

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

Answer 3

Wenn Sie nach mehr Darstellungen sind als von JSON abgedeckt sind, ich auschecken empfehlen Pyon (Python Object Notation) ... obwohl ich es beschränkt glaube 2.6 / 3.0 und höher, wie es auf dem ast Modul. Es behandelt benutzerdefinierte Klasseninstanzen und rekursiven Datentypen, unter anderem Features, die mehr ist, als durch JSON zur Verfügung gestellt.

Answer 4

Sie sollten jsonpickle Check-out ( https://github.com/jsonpickle/jsonpickle ). Es wird jedes Python-Objekt in eine JSON-Datei schreiben. Sie können diese Datei dann wieder in ein Python-Objekt lesen. Das Schöne daran ist, die zwischendurch Datei sehr gut lesbar ist, weil es json ist.

Answer 5

Was meinen Sie dies nicht in lesbarer Form ist ??? ;)

>>> 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, na ja, vielleicht auch nur es braucht etwas Übung ... oder man könnte betrügen ...

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

Sie würden immer noch das eingelegte Objekt aus einer Datei lesen müssen, aber würden Sie es nicht load benötigen. Also, wenn es ein „gefährliches“ Objekt ist, können Sie noch in der Lage sein, um das herauszufinden, bevor die load tun. Wenn Sie mit einem pickle stecken, könnte es eine gute Option für die Entzifferung, was Sie haben.

Answer 6

simplejson nutzen zu können, zuerst 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)

Ergebnisse in json Wesen:

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

Beachten Sie, dass sie kaum das Format des Wörterbuchs geändert überhaupt, aber man sollte es durch diesen Schritt ausführen gültig JSON-Daten zu gewährleisten.

Sie können weiter recht drucken Sie das Ergebnis:

import pprint
pprint.pprint(my_structure)

Ergebnisse in:

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

Answer 7

Es gibt AXON (textlich) Format, das die am besten kombinieren von JSON, XML und YAML. AXON-Format ist gut lesbar und relativ kompakt.

Der Python (2,7 / 3,3-3,7) -Modul pyaxon unterstützt load(s) / dump(s) Funktionalität, einschließlich iterative loading / dumping. Es ist schnell genug, um nützlich zu sein.

Betrachten einfaches Beispiel:

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

Es kann auch mehrere Objekte in der Nachricht verarbeiten:

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

und laden sie dann iterativ:

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