Hoe geneste woordenboeken mooi af te drukken?

Hoe kan ik een woordenboek met een diepte van ~4 in Python mooi afdrukken? Ik heb geprobeerd mooi af te drukken met pprint(), maar het werkte niet:

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

Ik wil gewoon een inspringing ("\t") voor elke nesting, zodat ik zoiets als dit krijg:

key1
    value1
    value2
    key2
       value1
       value2

enz.

Hoe kan ik dit doen?


Antwoord 1, autoriteit 100%

Ik weet niet precies hoe je wilt dat de opmaak eruitziet, maar je zou kunnen beginnen met een functie als deze:

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

Antwoord 2, autoriteit 96%

Mijn eerste gedachte was dat de JSON-serializer waarschijnlijk behoorlijk goed is in geneste woordenboeken, dus ik zou vals spelen en dat gebruiken:

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

Antwoord 3, autoriteit 43%

Je zou YAMLkunnen proberen via PyYAML. De output kan worden verfijnd. Ik stel voor om met het volgende te beginnen:

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

Het resultaat is zeer leesbaar; Het kan ook worden geparseerd naar Python indien nodig.

bewerken:

Voorbeeld:

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

4, Autoriteit 34%

Op deze manier kunt u deze op vrijwel drukken, bijvoorbeeld uw woordenboeknaam is yasin

import json
print (json.dumps(yasin, indent=2))

of, veiliger:

print (json.dumps(yasin, indent=2, default=str))

5, Autoriteit 23%

Vanaf wat er is gedaan, zie ik geen mooie printer die op zijn minst de uitvoer van de Python-tolk nabootst met zeer eenvoudige opmaak, dus hier is de mijne:

class Formatter(object):
    def __init__(self):
        self.types = {}
        self.htchar = '\t'
        self.lfchar = '\n'
        self.indent = 0
        self.set_formater(object, self.__class__.format_object)
        self.set_formater(dict, self.__class__.format_dict)
        self.set_formater(list, self.__class__.format_list)
        self.set_formater(tuple, self.__class__.format_tuple)
    def set_formater(self, obj, callback):
        self.types[obj] = callback
    def __call__(self, value, **args):
        for key in args:
            setattr(self, key, args[key])
        formater = self.types[type(value) if type(value) in self.types else object]
        return formater(self, value, self.indent)
    def format_object(self, value, indent):
        return repr(value)
    def format_dict(self, value, indent):
        items = [
            self.lfchar + self.htchar * (indent + 1) + repr(key) + ': ' +
            (self.types[type(value[key]) if type(value[key]) in self.types else object])(self, value[key], indent + 1)
            for key in value
        ]
        return '{%s}' % (','.join(items) + self.lfchar + self.htchar * indent)
    def format_list(self, value, indent):
        items = [
            self.lfchar + self.htchar * (indent + 1) + (self.types[type(item) if type(item) in self.types else object])(self, item, indent + 1)
            for item in value
        ]
        return '[%s]' % (','.join(items) + self.lfchar + self.htchar * indent)
    def format_tuple(self, value, indent):
        items = [
            self.lfchar + self.htchar * (indent + 1) + (self.types[type(item) if type(item) in self.types else object])(self, item, indent + 1)
            for item in value
        ]
        return '(%s)' % (','.join(items) + self.lfchar + self.htchar * indent)

Om het te initialiseren:

pretty = Formatter()

Het kan de toevoeging van formatters voor gedefinieerde typen ondersteunen, je hoeft alleen maar een functie hiervoor te maken zoals deze en deze te binden aan het gewenste type met set_formater :

from collections import OrderedDict
def format_ordereddict(self, value, indent):
    items = [
        self.lfchar + self.htchar * (indent + 1) +
        "(" + repr(key) + ', ' + (self.types[
            type(value[key]) if type(value[key]) in self.types else object
        ])(self, value[key], indent + 1) + ")"
        for key in value
    ]
    return 'OrderedDict([%s])' % (','.join(items) +
           self.lfchar + self.htchar * indent)
pretty.set_formater(OrderedDict, format_ordereddict)

Om historische redenen, houd ik de vorige mooie printer die een functie was in plaats van een klasse, maar ze kunnen allebei op dezelfde manier worden gebruikt, de klasse-versie staat eenvoudig veel meer toe:

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

Om het te gebruiken:

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

In vergelijking met andere versies:

  • Deze oplossing kijkt rechtstreeks voor objecttype, zodat u bijna alles kunt afdrukken, niet alleen een lijst of dict.
  • heeft geen enkele afhaling.
  • alles wordt in een string geplaatst, zodat je kunt doen wat je wilt.
  • De klasse en de functie is getest en werkt met Python 2.7 en 3.4.
  • U kunt alle soorten objecten binnen hebben, dit is hun representaties en niet de inhoud die in het resultaat wordt gezet (dus string heeft citaten, Unicode-string is volledig weergegeven …).
  • Met de klasse-versie kunt u opmaak toevoegen voor elk objecttype dat u wilt of wijzigt voor reeds gedefinieerde.
  • -toets kan van een geldig type zijn.
  • Indent en Newline-personage kan worden gewijzigd voor alles wat we willen.
  • DICT, lijst en tuples zijn behoorlijk gedrukt.

6, Autoriteit 13%

Een van de meest pythonische manieren om de reeds build pprint Module.

Het argument dat u nodig hebt om de afdrukdiepte te definiëren, is zoals u kunt verwachten depth

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

Dat is het!


7, Autoriteit 5%

Nog een optie met yapf:

from pprint import pformat
from yapf.yapflib.yapf_api import FormatCode
dict_example = {'1': '1', '2': '2', '3': [1, 2, 3, 4, 5], '4': {'1': '1', '2': '2', '3': [1, 2, 3, 4, 5]}}
dict_string = pformat(dict_example)
formatted_code, _ = FormatCode(dict_string)
print(formatted_code)

Uitvoer:

{
    '1': '1',
    '2': '2',
    '3': [1, 2, 3, 4, 5],
    '4': {
        '1': '1',
        '2': '2',
        '3': [1, 2, 3, 4, 5]
    }
}

Antwoord 8, autoriteit 5%

Ik moest ook de parameter defaultdoorgeven, als volgt:

print(json.dumps(my_dictionary, indent=4, default=str))

en als u de sleutels gesorteerd wilt hebben, kunt u het volgende doen:

print(json.dumps(my_dictionary, sort_keys=True, indent=4, default=str))

om dit type fout te herstellen:

TypeError: Object of type 'datetime' is not JSON serializable

wat veroorzaakt werd doordat datetimes enkele waarden in het woordenboek waren.


Antwoord 9, autoriteit 3%

Zoals anderen hebben gepost, kunt u recursie/dfs gebruiken om de geneste woordenboekgegevens af te drukken en recursief aan te roepen als het een woordenboek is; druk anders de gegevens af.

def print_json(data):
    if type(data) == dict:
            for k, v in data.items():
                    print k
                    print_json(v)
    else:
            print data

Antwoord 10, autoriteit 3%

U kunt print-dict

gebruiken

from print_dict import pd
dict1 = {
    'key': 'value'
} 
pd(dict1)

Uitvoer:

{
    'key': 'value'
}

Uitvoer van dezePython-code:

{
    'one': 'value-one',
    'two': 'value-two',
    'three': 'value-three',
    'four': {
        '1': '1',
        '2': '2',
        '3': [1, 2, 3, 4, 5],
        '4': {
            'method': <function custom_method at 0x7ff6ecd03e18>,
            'tuple': (1, 2),
            'unicode': '✓',
            'ten': 'value-ten',
            'eleven': 'value-eleven',
            '3': [1, 2, 3, 4]
        }
    },
    'object1': <__main__.Object1 object at 0x7ff6ecc588d0>,
    'object2': <Object2 info>,
    'class': <class '__main__.Object1'>
}

Installeren:

$ pip install print-dict

Disclosure: ik ben de auteur van print-dict


Antwoord 11, autoriteit 2%

poutkan vrijwel alles afdrukken wat je erop gooit, bijvoorbeeld (het lenen van datavan een ander antwoord):

data = {'a':2, 'b':{'x':3, 'y':{'t1': 4, 't2':5}}}
pout.vs(data)

zou resulteren in uitvoer die op het scherm wordt afgedrukt, zoals:

{
    'a': 2,
    'b':
    {
        'y':
        {
            't2': 5,
            't1': 4
        },
        'x': 3
    }
}

of u kunt de geformatteerde tekenreeksuitvoer van uw object retourneren:

v = pout.s(data)

De primaire use case is voor debuggen, dus het verslikt zich niet in objectinstanties of wat dan ook en het verwerkt unicode-uitvoer zoals je zou verwachten, werkt in python 2.7 en 3.

openbaarmaking: ik ben de auteur en beheerder van pout.


Antwoord 12, autoriteit 2%

Ik heb het antwoord van sth’s antwoordgenomen en enigszins aangepast aan mijn behoeften aan geneste woordenboeken en lijsten:

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

Wat me dan output geeft als:

>>> 
xs:schema
    @xmlns:xs
        http://www.w3.org/2001/XMLSchema
    xs:redefine
        @schemaLocation
            base.xsd
        xs:complexType
            @name
                Extension
            xs:complexContent
                xs:restriction
                    @base
                        Extension
                    xs:sequence
                        xs:element
                            @name
                                Policy
                            @minOccurs
                                1
                            xs:complexType
                                xs:sequence
                                    xs:element
                                            ...

Antwoord 13

Ik heb deze eenvoudige code geschreven om de algemene structuur van een json-object in Python af te drukken.

def getstructure(data, tab = 0):
    if type(data) is dict:
        print ' '*tab + '{' 
        for key in data:
            print ' '*tab + '  ' + key + ':'
            getstructure(data[key], tab+4)
        print ' '*tab + '}'         
    elif type(data) is list and len(data) > 0:
        print ' '*tab + '['
        getstructure(data[0], tab+4)
        print ' '*tab + '  ...'
        print ' '*tab + ']'

het resultaat voor de volgende gegevens

a = {'list':['a','b',1,2],'dict':{'a':1,2:'b'},'tuple':('a','b',1,2),'function':'p','unicode':u'\xa7',("tuple","key"):"valid"}
getstructure(a)

is erg compact en ziet er als volgt uit:

{
  function:
  tuple:
  list:
    [
      ...
    ]
  dict:
    {
      a:
      2:
    }
  unicode:
  ('tuple', 'key'):
}

Antwoord 14

Ik heb het volgende geprobeerd en kreeg de gewenste resultaten

Methode 1:
Stap 1: Installeer print_dictdoor de volgende opdracht in cmd

te typen

pip install print_dict

Stap 2: Importeer print_dict als

from print_dict import pd

Stap 3: Afdrukken met pd

pd(your_dictionary_name)

Voorbeelduitgang:

{
    'Name': 'Arham Rumi',
    'Age': 21,
    'Movies': ['adas', 'adfas', 'fgfg', 'gfgf', 'vbxbv'],
    'Songs': ['sdfsd', 'dfdgfddf', 'dsdfd', 'sddfsd', 'sdfdsdf']
}

Methode 2:
We kunnen ook forlus gebruiken om het woordenboek af te drukken met behulp van itemsmethode

for key, Value in your_dictionary_name.items():
    print(f"{key} : {Value}")

15

sth, ik zink dat mooi;)

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

16

This class prints out a complex nested dictionary with sub dictionaries and sub lists.  
##
## Recursive class to parse and print complex nested dictionary
##
class NestedDictionary(object):
    def __init__(self,value):
        self.value=value
    def print(self,depth):
        spacer="--------------------"
        if type(self.value)==type(dict()):
            for kk, vv in self.value.items():
                if (type(vv)==type(dict())):
                    print(spacer[:depth],kk)
                    vvv=(NestedDictionary(vv))
                    depth=depth+3
                    vvv.print(depth)
                    depth=depth-3
                else:
                    if (type(vv)==type(list())):
                        for i in vv:
                            vvv=(NestedDictionary(i))
                            depth=depth+3
                            vvv.print(depth)
                            depth=depth-3
                    else:
                        print(spacer[:depth],kk,vv) 
##
## Instatiate and execute - this prints complex nested dictionaries
## with sub dictionaries and sub lists
## 'something' is a complex nested dictionary
MyNest=NestedDictionary(weather_com_result)
MyNest.print(0)

17

De moderne oplossing hier is om rijk te gebruiken. Installeren met

pip install rich

en gebruik als

from rich import print
d = {
    "Alabama": "Montgomery",
    "Alaska": "Juneau",
    "Arizona": "Phoenix",
    "Arkansas": "Little Rock",
    "California": "Sacramento",
    "Colorado": "Denver",
    "Connecticut": "Hartford",
    "Delaware": "Dover",
    "Florida": "Tallahassee",
    "Georgia": "Atlanta",
    "Hawaii": "Honolulu",
    "Idaho": "Boise",
}
print(d)

De uitvoer is mooi ingesprongen:


Antwoord 18

Hier is een functie die ik heb geschreven op basis van de opmerking van sth. Het werkt hetzelfde als json.dumps met inspringing, maar ik gebruik tabs in plaats van ruimte voor inspringingen. In Python 3.2+ kun je inspringen direct specificeren als een ‘\t’, maar niet in 2.7.

def pretty_dict(d):
    def pretty(d, indent):
        for i, (key, value) in enumerate(d.iteritems()):
            if isinstance(value, dict):
                print '{0}"{1}": {{'.format( '\t' * indent, str(key))
                pretty(value, indent+1)
                if i == len(d)-1:
                    print '{0}}}'.format( '\t' * indent)
                else:
                    print '{0}}},'.format( '\t' * indent)
            else:
                if i == len(d)-1:
                    print '{0}"{1}": "{2}"'.format( '\t' * indent, str(key), value)
                else:
                    print '{0}"{1}": "{2}",'.format( '\t' * indent, str(key), value)
    print '{'
    pretty(d,indent=1)
    print '}'

Bijvoorbeeld:

>>> dict_var = {'a':2, 'b':{'x':3, 'y':{'t1': 4, 't2':5}}}
>>> pretty_dict(dict_var)
{
    "a": "2",
    "b": {
        "y": {
            "t2": "5",
            "t1": "4"
        },
        "x": "3"
    }
}

Antwoord 19

Hier is iets dat elk soort geneste woordenboek zal afdrukken, terwijl de ‘ouder’-woordenboeken onderweg worden bijgehouden.

dicList = list()
def prettierPrint(dic, dicList):
count = 0
for key, value in dic.iteritems():
    count+=1
    if str(value) == 'OrderedDict()':
        value = None
    if not isinstance(value, dict):
        print str(key) + ": " + str(value)
        print str(key) + ' was found in the following path:',
        print dicList
        print '\n'
    elif isinstance(value, dict):
        dicList.append(key)
        prettierPrint(value, dicList)
    if dicList:
         if count == len(dic):
             dicList.pop()
             count = 0
prettierPrint(dicExample, dicList)

Dit is een goed startpuntom te printen volgens verschillende formaten, zoals die gespecificeerd in OP. Het enige dat u echt hoeft te doen, zijn bewerkingen rond de Printblokken. Merk op dat het lijkt om te zien of de waarde ‘OrderedDict()’ is. Afhankelijk van of je iets gebruikt uit Container datatypes Collections, moet je deze soort fail-safes, zodat het elif-blok het vanwege zijn naam niet als een extra woordenboek ziet. Vanaf nu is er een voorbeeldwoordenboek zoals

example_dict = {'key1': 'value1',
            'key2': 'value2',
            'key3': {'key3a': 'value3a'},
            'key4': {'key4a': {'key4aa': 'value4aa',
                               'key4ab': 'value4ab',
                               'key4ac': 'value4ac'},
                     'key4b': 'value4b'}

wordt afgedrukt

key3a: value3a
key3a was found in the following path: ['key3']
key2: value2
key2 was found in the following path: []
key1: value1
key1 was found in the following path: []
key4ab: value4ab
key4ab was found in the following path: ['key4', 'key4a']
key4ac: value4ac
key4ac was found in the following path: ['key4', 'key4a']
key4aa: value4aa
key4aa was found in the following path: ['key4', 'key4a']
key4b: value4b
key4b was found in the following path: ['key4']

~ wijzigen van de code om het formaat van de vraag ~

te passen

lastDict = list()
dicList = list()
def prettierPrint(dic, dicList):
    global lastDict
    count = 0
    for key, value in dic.iteritems():
        count+=1
        if str(value) == 'OrderedDict()':
            value = None
        if not isinstance(value, dict):
            if lastDict == dicList:
                sameParents = True
            else:
                sameParents = False
            if dicList and sameParents is not True:
                spacing = ' ' * len(str(dicList))
                print dicList
                print spacing,
                print str(value)
            if dicList and sameParents is True:
                print spacing,
                print str(value)
            lastDict = list(dicList)
        elif isinstance(value, dict):
            dicList.append(key)
            prettierPrint(value, dicList)
        if dicList:
             if count == len(dic):
                 dicList.pop()
                 count = 0

Met dezelfde voorbeeldcode wordt het volgende afdrukt:

['key3']
         value3a
['key4', 'key4a']
                  value4ab
                  value4ac
                  value4aa
['key4']
         value4b

Dit is niet precies wat wordt gevraagd in OP. Het verschil is dat een ouder ^ n nog steeds wordt afgedrukt, in plaats van afwezig te zijn en vervangen door witte ruimte. Om naar Op’s Formaat te gaan, moet je iets doen als het volgende: vermenig je DICList met de -thict . U kunt dit doen door een nieuw woordenboek te maken en de inhoud van de DICList erop te kopiëren, te controleren of I in het gekopieerde woordenboek hetzelfde is als I in Stuurdict, en – indien het is – WhiteSpace schrijven aan dat I -positie met behulp van de functie String Multiplier.


20

van deze link :

def prnDict(aDict, br='\n', html=0,
            keyAlign='l',   sortKey=0,
            keyPrefix='',   keySuffix='',
            valuePrefix='', valueSuffix='',
            leftMargin=0,   indent=1 ):
    '''
return a string representive of aDict in the following format:
    {
     key1: value1,
     key2: value2,
     ...
     }
Spaces will be added to the keys to make them have same width.
sortKey: set to 1 if want keys sorted;
keyAlign: either 'l' or 'r', for left, right align, respectively.
keyPrefix, keySuffix, valuePrefix, valueSuffix: The prefix and
   suffix to wrap the keys or values. Good for formatting them
   for html document(for example, keyPrefix='<b>', keySuffix='</b>'). 
   Note: The keys will be padded with spaces to have them
         equally-wide. The pre- and suffix will be added OUTSIDE
         the entire width.
html: if set to 1, all spaces will be replaced with '&nbsp;', and
      the entire output will be wrapped with '<code>' and '</code>'.
br: determine the carriage return. If html, it is suggested to set
    br to '<br>'. If you want the html source code eazy to read,
    set br to '<br>\n'
version: 04b52
author : Runsun Pan
require: odict() # an ordered dict, if you want the keys sorted.
         Dave Benjamin 
         http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/161403
    '''
    if aDict:
        #------------------------------ sort key
        if sortKey:
            dic = aDict.copy()
            keys = dic.keys()
            keys.sort()
            aDict = odict()
            for k in keys:
                aDict[k] = dic[k]
        #------------------- wrap keys with ' ' (quotes) if str
        tmp = ['{']
        ks = [type(x)==str and "'%s'"%x or x for x in aDict.keys()]
        #------------------- wrap values with ' ' (quotes) if str
        vs = [type(x)==str and "'%s'"%x or x for x in aDict.values()] 
        maxKeyLen = max([len(str(x)) for x in ks])
        for i in range(len(ks)):
            #-------------------------- Adjust key width
            k = {1            : str(ks[i]).ljust(maxKeyLen),
                 keyAlign=='r': str(ks[i]).rjust(maxKeyLen) }[1]
            v = vs[i]        
            tmp.append(' '* indent+ '%s%s%s:%s%s%s,' %(
                        keyPrefix, k, keySuffix,
                        valuePrefix,v,valueSuffix))
        tmp[-1] = tmp[-1][:-1] # remove the ',' in the last item
        tmp.append('}')
        if leftMargin:
          tmp = [ ' '*leftMargin + x for x in tmp ]
        if html:
            return '<code>%s</code>' %br.join(tmp).replace(' ','&nbsp;')
        else:
            return br.join(tmp)     
    else:
        return '{}'
'''
Example:
>>> a={'C': 2, 'B': 1, 'E': 4, (3, 5): 0}
>>> print prnDict(a)
{
 'C'   :2,
 'B'   :1,
 'E'   :4,
 (3, 5):0
}
>>> print prnDict(a, sortKey=1)
{
 'B'   :1,
 'C'   :2,
 'E'   :4,
 (3, 5):0
}
>>> print prnDict(a, keyPrefix="<b>", keySuffix="</b>")
{
 <b>'C'   </b>:2,
 <b>'B'   </b>:1,
 <b>'E'   </b>:4,
 <b>(3, 5)</b>:0
}
>>> print prnDict(a, html=1)
<code>{
&nbsp;'C'&nbsp;&nbsp;&nbsp;:2,
&nbsp;'B'&nbsp;&nbsp;&nbsp;:1,
&nbsp;'E'&nbsp;&nbsp;&nbsp;:4,
&nbsp;(3,&nbsp;5):0
}</code>
>>> b={'car': [6, 6, 12], 'about': [15, 9, 6], 'bookKeeper': [9, 9, 15]}
>>> print prnDict(b, sortKey=1)
{
 'about'     :[15, 9, 6],
 'bookKeeper':[9, 9, 15],
 'car'       :[6, 6, 12]
}
>>> print prnDict(b, keyAlign="r")
{
        'car':[6, 6, 12],
      'about':[15, 9, 6],
 'bookKeeper':[9, 9, 15]
}
'''

Antwoord 21

Gebruik deze functie:

def pretty_dict(d, n=1):
    for k in d:
        print(" "*n + k)
        try:
            pretty_dict(d[k], n=n+4)
        except TypeError:
            continue

Noem het zo:

pretty_dict(mydict)

Antwoord 22

Dit is wat ik bedacht tijdens het werken aan een les die een woordenboek moest schrijven in een .txt-bestand:

@staticmethod
def _pretty_write_dict(dictionary):
    def _nested(obj, level=1):
        indentation_values = "\t" * level
        indentation_braces = "\t" * (level - 1)
        if isinstance(obj, dict):
            return "{\n%(body)s%(indent_braces)s}" % {
                "body": "".join("%(indent_values)s\'%(key)s\': %(value)s,\n" % {
                    "key": str(key),
                    "value": _nested(value, level + 1),
                    "indent_values": indentation_values
                } for key, value in obj.items()),
                "indent_braces": indentation_braces
            }
        if isinstance(obj, list):
            return "[\n%(body)s\n%(indent_braces)s]" % {
                "body": "".join("%(indent_values)s%(value)s,\n" % {
                    "value": _nested(value, level + 1),
                    "indent_values": indentation_values
                } for value in obj),
                "indent_braces": indentation_braces
            }
        else:
            return "\'%(value)s\'" % {"value": str(obj)}
    dict_text = _nested(dictionary)
    return dict_text

Nu, als we een woordenboek als volgt hebben:

some_dict = {'default': {'ENGINE': [1, 2, 3, {'some_key': {'some_other_key': 'some_value'}}], 'NAME': 'some_db_name', 'PORT': '', 'HOST': 'localhost', 'USER': 'some_user_name', 'PASSWORD': 'some_password', 'OPTIONS': {'init_command': 'SET foreign_key_checks = 0;'}}}

en wij doen:

print(_pretty_write_dict(some_dict))

We krijgen:

{
    'default': {
        'ENGINE': [
            '1',
            '2',
            '3',
            {
                'some_key': {
                    'some_other_key': 'some_value',
                },
            },
        ],
        'NAME': 'some_db_name',
        'OPTIONS': {
            'init_command': 'SET foreign_key_checks = 0;',
        },
        'HOST': 'localhost',
        'USER': 'some_user_name',
        'PASSWORD': 'some_password',
        'PORT': '',
    },
}

Antwoord 23

Ik heb gebruikt wat jullie me hebben geleerd plus de kracht van decorateurs om de klassieke printfunctie te overbelasten. Verander gewoon het streepje naar uw behoeften. Ik heb het toegevoegd als een gistin github voor het geval je het een ster wilt geven (opslaan).

def print_decorator(func):
    """
    Overload Print function to pretty print Dictionaries 
    """
    def wrapped_func(*args,**kwargs):
        if isinstance(*args, dict):
            return func(json.dumps(*args, sort_keys=True, indent=2, default=str))
        else:
            return func(*args,**kwargs)
    return wrapped_func
print = print_decorator(print)

Gebruik nu gewoon printen.

Other episodes