jolis dictionnaires imbriqués en Python?

Question

Comment puis-je imprimer un dictionnaire avec une profondeur de ~ 4 en Python? J'ai essayé de jolies impressions avec pprint mais cela n'a pas fonctionné:

 import pprint 
pp = pprint.PrettyPrinter(indent=4)
pp.pprint(mydict)
 

Je veux simplement une identité ("\ t") pour chaque imbrication, afin d'obtenir quelque chose comme ceci:

 key1
    value1
    value2
    key2
       value1
       value2
 

etc.

Comment puis-je faire ceci?

Answer 1

Ma première pensée a été que le sérialiseur JSON est probablement assez bon pour les dictionnaires imbriqués, alors je tricherais et utiliserais ça:

 >>> import json
>>> print json.dumps({'a':2, 'b':{'x':3, 'y':{'t1': 4, 't2':5}}},
...                  sort_keys=True, indent=4)
{
    "a": 2,
    "b": {
        "x": 3,
        "y": {
            "t1": 4,
            "t2": 5
        }
    }
}
 

Answer 2

Je ne sais pas exactement à quoi vous voulez que le formatage ressemble, mais vous pourriez commencer avec une fonction comme celle-ci:

 def pretty(d, indent=0):
   for key, value in d.iteritems():
      print '\t' * indent + str(key)
      if isinstance(value, dict):
         pretty(value, indent+1)
      else:
         print '\t' * (indent+1) + str(value)
 

Answer 3

Vous pouvez essayer YAML via PyYAML . Sa sortie peut être ajustée. Je suggère de commencer par ce qui suit:

yaml.dump(data, allow_unicode=True, default_flow_style=False)

Le résultat est très lisible. il peut également être analysé en Python si nécessaire.

Modifier:

Exemple:

 >>> import yaml
>>> data = {'a':2, 'b':{'x':3, 'y':{'t1': 4, 't2':5}}}
>>> print yaml.dump(data, default_flow_style=False)
a: 2
b:
  x: 3
  y:
    t1: 4
    t2: 5
 

Answer 4

Comme de ce qui a été fait, je ne vois pas assez imprimante au moins imite la sortie de l'interpréteur python avec de très simple mise en forme, donc voici la mienne :

def pretty(value,htchar="\t",lfchar="\n",indent=0):
  if type(value) in [dict]:
    return "{%s%s%s}"%(",".join(["%s%s%s: %s"%(lfchar,htchar*(indent+1),repr(key),pretty(value[key],htchar,lfchar,indent+1))for key in value]),lfchar,(htchar*indent))
  elif type(value) in [list,tuple]:
    return (type(value)is list and"[%s%s%s]"or"(%s%s%s)")%(",".join(["%s%s%s"%(lfchar,htchar*(indent+1),pretty(item,htchar,lfchar,indent+1))for item in value]),lfchar,(htchar*indent))
  else:
    return repr(value)

Voici un one-liner version pour ceux qui veulent, c'est de 342 octets de long.

pretty=(lambda a:lambda v,t="\t",n="\n",i=0:a(a,v,t,n,i))(lambda f,v,t,n,i:"{%s%s%s}"%(",".join(["%s%s%s: %s"%(n,t*(i+1),repr(k),f(f,v[k],t,n,i+1))for k in v]),n,(t*i)) if type(v)in[dict] else (type(v)in[list]and"[%s%s%s]"or"(%s%s%s)")%(",".join(["%s%s%s"%(n,t*(i+1),f(f,k,t,n,i+1))for k in v]),n,(t*i)) if type(v)in[list,tuple] else repr(v))

Pour l'utiliser :

>>> a = {'list':['a','b',1,2],'dict':{'a':1,2:'b'},'tuple':('a','b',1,2),'function':pretty,'unicode':u'\xa7'}
>>> a
{'function': <function pretty at 0x7f8a87c179b0>, 'dict': {'a': 1, 2: 'b'}, 'list': ['a', 'b', 1, 2], 'unicode': u'\xa7', 'tuple': ('a', 'b', 1, 2)}
>>> print(pretty(a))
{
    'function': <function pretty at 0x7f8a87c179b0>,
    'dict': {
        'a': 1,
        2: 'b'
    },
    'list': [
        'a',
        'b',
        1,
        2
    ],
    'unicode': u'\xa7',
    'tuple': (
        'a',
        'b',
        1,
        2
    )
}

Comparé à d'autres versions :

• La solution est centrée sur la recherche pour le type de valeur de la première et de la mise en forme pour avoir un maximum de compatibilité.
• Tout est mis à l'intérieur d'une chaîne, de sorte que vous pouvez faire ce que vous voulez avec elle.
• Cette fonction a été testé et fonctionne avec Python 2.7 et 3.4.
• Vous pouvez avoir tout type d'objets à l'intérieur, c'est leurs représentations et non pas la leur contenu que d'être mis dans le résultat (donc de la chaîne des citations, chaîne Unicode sont pleinement représentés ...).
• Tiret et le caractère de Saut de ligne peut être changé pour tout ce que nous aimerions.
• Dict, la Liste et les Tuples sont assez imprimés.

Answer 5

Sth, je coule c'est joli;)

 def pretty(d, indent=0):
    for key, value in d.iteritems():
        if isinstance(value, dict):
            print '\t' * indent + (("%30s: {\n") % str(key).upper())
            pretty(value, indent+1)
            print '\t' * indent + ' ' * 32 + ('} # end of %s #\n' % str(key).upper())
        elif isinstance(value, list):
            for val in value:
                print '\t' * indent + (("%30s: [\n") % str(key).upper())
                pretty(val, indent+1)
                print '\t' * indent + ' ' * 32 + ('] # end of %s #\n' % str(key).upper())
        else:
            print '\t' * indent + (("%30s: %s") % (str(key).upper(),str(value)))