Serializzazione di oggetti leggibili dall'uomo Python
-
03-07-2019 - |
Domanda
Ho bisogno di memorizzare strutture Python fatte di liste / dizionari, tuple in un formato leggibile dall'uomo. L'idea è come usare qualcosa di simile a pickle , ma il pickle non è amico dell'uomo. Altre opzioni che mi vengono in mente sono YAML (tramite PyYAML e JSON (tramite simplejson ) serializzatori.
Qualche altra opzione che ti viene in mente?
Grazie in anticipo.
Soluzione
Per semplici casi vengono in mente pprint () ed eval ().
Usando il tuo esempio:
>>> 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}}
>>>
Ci penserei due volte a fissare due requisiti con lo stesso strumento. Hai mai pensato di usare pickle per la serializzazione e poi pprint () (o un visualizzatore di oggetti più elaborato) per gli umani che guardano gli oggetti?
Altri suggerimenti
Se è solo elenco Python, dizionario e oggetto tupla. - JSON è la strada da percorrere. È leggibile dall'uomo, molto facile da gestire e anche indipendente dalla lingua.
Attenzione: le tuple verranno convertite in elenchi in simplejson.
In [109]: simplejson.loads(simplejson.dumps({'d':(12,3,4,4,5)}))
Out[109]: {u'd': [12, 3, 4, 4, 5]}
Se cerchi più rappresentazioni di quelle coperte da JSON, ti consiglio vivamente di dare un'occhiata a PyON (Python Object Notation) ... anche se credo che sia limitato a 2.6 / 3.0 e versioni successive, in quanto si basa sul modulo ast . Gestisce istanze di classe personalizzate e tipi di dati ricorsivi, tra le altre funzionalità, che è più di quanto sia fornito da JSON.
Dovresti dare un'occhiata a jsonpickle ( https://github.com/jsonpickle/jsonpickle ). Scriverà qualsiasi oggetto Python in un file JSON. È quindi possibile rileggere quel file in un oggetto Python. La cosa bella è che il file intermedio è molto leggibile perché è json.
Cosa vuoi dire con questo non è leggibile dall'uomo ??? ;)
>>> 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, beh, forse ci vuole solo un po 'di pratica ... o potresti imbrogliare ...
>>> 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
>>>
Dovresti comunque leggere l'oggetto decapato da un file, tuttavia non dovrai caricarlo caricarlo
. Quindi, se è un "pericoloso" oggetto, potresti comunque riuscire a capirlo prima di fare il load
. Se sei bloccato con un pickle
, potrebbe essere una buona opzione per decifrare ciò che hai.
Per utilizzare simplejson prima 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)
risulta in json:
{"age": 27, "subdict": {"second": 2, "third": 3, "first": 1}, "name": "Joe", "numbers": [1, 2, 3, 4, 5]}
Si noti che non ha cambiato affatto il formato del dizionario, ma è necessario eseguirlo attraverso questo passaggio per garantire dati JSON validi.
Puoi anche stampare piuttosto il risultato:
import pprint
pprint.pprint(my_structure)
risulta in:
{'age': 27,
'name': 'Joe',
'numbers': [1, 2, 3, 4, 5],
'subdict': {'first': 1, 'second': 2, 'third': 3}}
Esiste AXON (testo) formato che combina il migliore di JSON, XML e YAML. Il formato AXON è abbastanza leggibile e relativamente compatto.
Il modulo python (2.7 / 3.3-3.7) pyaxon supporta load ( s)
/ dump (s)
, incluso il caricamento iterativo
/ dumping
. È sufficientemente veloce per essere utile.
Prendi in considerazione un semplice esempio:
>>> 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}}
Può anche gestire più oggetti nel messaggio:
>>> 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}
e quindi caricarli iterativamente:
for d in axon.iloads(msg):
print(d)