Sérialisation d'objets Python lisible par l'homme

Question

Je dois stocker les structures Python constituées de listes / dictionnaires et de nuplets dans un format lisible par l'homme. L'idée est comme utiliser quelque chose de similaire à pickle , mais pickle n'est pas convivial. Les autres options qui me viennent à l’esprit sont YAML (via PyYAML et JSON (via simplejson ) sérialiseurs.

Une autre option qui vous vient à l’esprit?

Merci d'avance.

Answer 1

Pour les cas simples, pprint () et eval () viennent à l’esprit.

En utilisant votre exemple:

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

Je réfléchirais à deux fois avant de résoudre deux exigences avec le même outil. Avez-vous envisagé d’utiliser pickle pour la sérialisation, puis pprint () (ou un visualiseur d’objets plus sophistiqué) pour les humains regardant les objets?

Answer 2

Si c'est seulement la liste Python, le dictionnaire et l'objet tuple. - JSON est la voie à suivre. Il est lisible par l'homme, très facile à manipuler et indépendant du langage.

Attention: les nuplets seront convertis en listes dans simplejson.

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

Answer 3

Si vous recherchez plus de représentations que ne le couvre JSON, je vous recommande vivement de vérifier PyON (Notation d’objet Python) ... bien que j’estime qu’elle est limitée à 2.6 / 3.0 et aux versions ultérieures, car elle repose sur le module ast . Il gère des instances de classe personnalisées et des types de données récursifs, entre autres fonctionnalités, qui sont plus nombreuses que celles fournies par JSON.

Answer 4

Vous devriez consulter jsonpickle ( https://github.com/jsonpickle/jsonpickle ). Il écrira n'importe quel objet python dans un fichier json. Vous pouvez ensuite lire ce fichier dans un objet python. La bonne chose est que le fichier inbetween est très lisible, car c’est json.

Answer 5

Qu'est-ce que tu veux dire par ceci n'est pas lisible par l'homme ??? ;)

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

D'accord, bon, il faut peut-être un peu de pratique & # 8230; ou vous pourriez tricher ...

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

Vous devez toujours lire l'objet décapé à partir d'un fichier, mais vous n'avez pas besoin de le charger . Donc, si c'est un "dangereux" objet, vous pourrez peut-être comprendre cela avant de lancer load . Si vous êtes coincé avec un pickle , cela pourrait être une bonne option pour déchiffrer ce que vous avez.

Answer 6

Pour utiliser d'abord simplejson 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)

a pour résultat que json est:

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

Notez que le format du dictionnaire n'a pratiquement pas changé, mais vous devez l'exécuter tout au long de cette étape pour garantir la validité des données JSON.

Vous pouvez également imprimer le résultat:

import pprint
pprint.pprint(my_structure)

entraîne:

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

Answer 7

Un format de AXON (texte) associe le meilleur de JSON, XML et YAML. Le format AXON est assez lisible et relativement compact.

Le module python (2.7 / 3.3-3.7) pyaxon prend en charge load ( s) / dump (s) , y compris itératif chargement / dumping . C'est suffisamment rapide pour être utile.

Prenons un exemple simple:

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

Il peut également gérer plusieurs objets dans le message:

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

puis chargez-les de manière itérative:

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