Python serialização objeto legível
-
03-07-2019 - |
Pergunta
i precisa armazenar estruturas Python feitas de listas / dicionários, tuplas em um formato legível. A idéia é como usar algo semelhante ao picles , mas picles não é humano-friendly. Outras opções que vêm à minha mente são YAML (através de PyYAML e JSON (através de simplejson ) serializers.
Qualquer outra opção que vem à sua mente?
Agradecemos antecipadamente.
Solução
Para casos simples pprint () e eval () vêm à mente.
Usando o seu exemplo:
>>> 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}}
>>>
Eu pensaria duas vezes sobre a fixação de dois requisitos com a mesma ferramenta. Você já pensou em usar pickle para a serialização e depois pprint () (ou um visualizador mais chique objeto) para os seres humanos olhando para os objetos?
Outras dicas
Se a sua apenas lista Python, dicionário e tuple objeto. - JSON é o caminho a percorrer. Sua legível, muito fácil de manusear e independente linguagem também.
Atenção:. Tuples será convertido em listas em simplejson
In [109]: simplejson.loads(simplejson.dumps({'d':(12,3,4,4,5)}))
Out[109]: {u'd': [12, 3, 4, 4, 5]}
Se você é depois de mais representações que são cobertos por JSON, eu recomendo verificar pyon (Object Notation Python) ... embora eu acredite que ele está restrito a 2,6 / 3,0 e acima, uma vez que conta com o ast módulo. Ele lida com instâncias de classe personalizada e tipo recursivo, entre outras características, que é mais do que o previsto por JSON.
Você deve verificar se jsonpickle ( https://github.com/jsonpickle/jsonpickle ). Ele vai escrever qualquer objeto python em um arquivo JSON. Você pode então ler que volta arquivo em um objeto python. O bom é que o arquivo inbetween é muito legível porque é JSON.
O que quer dizer isso não é legível ??? ;)
>>> 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, bem, talvez ele só leva um pouco de prática ... ou você poderia enganar ...
>>> 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
>>>
Você ainda tem que ler o objeto em conserva de um arquivo, no entanto, você não precisaria load
-lo. Então, se é um objeto "perigoso", você ainda pode ser capaz de descobrir isso antes de fazer o load
. Se você está preso com um pickle
, pode ser uma boa opção para decifrar o que você tem.
Para usar simplejson primeira 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)
resulta em ser json:
{"age": 27, "subdict": {"second": 2, "third": 3, "first": 1}, "name": "Joe", "numbers": [1, 2, 3, 4, 5]}
Observe que a sua quase não mudou o formato do dicionário em tudo, mas você deve executá-lo através deste passo para garantir que os dados JSON válido.
Você pode ainda bastante imprimir o resultado:
import pprint
pprint.pprint(my_structure)
resulta em:
{'age': 27,
'name': 'Joe',
'numbers': [1, 2, 3, 4, 5],
'subdict': {'first': 1, 'second': 2, 'third': 3}}
Há AXON (textual) formato que combine o melhor de JSON, XML e YAML. formato AXON é bastante legível e relativamente compacto.
O pitão (2,7 / 3,3-3,7) módulo pyaxon funcionalidade suportes load(s)
/ dump(s)
, incluindo iterativo loading
/ dumping
. É suficientemente rápido, a fim de ser útil.
Veja o exemplo simples:
>>> 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}}
Ele também pode lidar com vários objetos na mensagem:
>>> 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, em seguida, carregá-los de forma iterativa:
for d in axon.iloads(msg):
print(d)