我不确定你到底想要什么样的格式，但你可以从这样一个函数开始:

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

我自己是一个相对的python新手，但过去几周我一直在使用嵌套字典，这就是我想到的。

你应该尝试使用堆栈。将根字典中的键变成一个列表的列表:

stack = [ root.keys() ]     # Result: [ [root keys] ]

按照从最后到第一个的相反顺序，查找字典中的每个键，看看它的值是否(也是)一个字典。如果不是，打印密钥，然后删除它。但是，如果键是的值是字典，则打印该键，然后将该值的键附加到堆栈的末尾，并以相同的方式开始处理该列表，对每个新的键列表进行递归重复。

如果每个列表中第二个键的值是一个字典，那么在几轮之后，你会得到这样的结果:

[['key 1','key 2'],['key 2.1','key 2.2'],['key 2.2.1','key 2.2.2'],[`etc.`]]

这种方法的优点是缩进只是\t乘以堆栈的长度:

indent = "\t" * len(stack)

缺点是为了检查每个键，你需要散列到相关的子字典，尽管这可以通过列表理解和简单的for循环轻松处理:

path = [li[-1] for li in stack]
# The last key of every list of keys in the stack


sub = root
for p in path:
sub = sub[p]




if type(sub) == dict:
stack.append(sub.keys()) # And so on

注意，这种方法需要清除尾随的空列表，而且删除后跟空列表的任何列表中的最后一个键(当然，这可能会创建另一个空列表，等等)。

还有其他方法来实现这个方法，但希望这能给你一个基本的想法。

编辑:如果你不想经历所有这些，pprint模块将以良好的格式打印嵌套字典。

我的第一个想法是JSON序列化器可能很擅长嵌套字典，所以我会欺骗并使用它:

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

某物，我觉得很漂亮

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

你可以通过PyYAML尝试YAML。它的输出可以微调。我建议从以下开始:

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

结果是非常可读;如果需要，还可以解析回Python。

编辑:

例子:

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

下面是我根据sth的注释写的函数。它的工作原理与json相同。转储与缩进，但我使用制表符而不是缩进的空间。在Python 3.2+中，您可以直接将缩进指定为'\t'，但在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 '}'

例:

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

至于已经做了什么，我没有看到任何漂亮的打印机，至少模仿python解释器的输出非常简单的格式，所以这里是我的:

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)

要初始化它:

pretty = Formatter()

它可以支持为已定义的类型添加格式化器，你只需要为它创建一个函数，然后用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)

由于历史原因，我保留了之前的漂亮打印机，它是一个函数而不是一个类，但它们都可以以同样的方式使用，类版本只是允许更多:

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)

使用它:

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

相对于其他版本:

• 这个解决方案直接寻找对象类型，所以你可以打印几乎所有的东西，而不仅仅是列表或字典。
• 没有任何依赖关系。
• 所有东西都放在一个字符串中，所以你可以对它做任何你想做的事情。
• 类和函数已经过测试，可在Python 2.7和3.4中使用。
• 你可以在里面有所有类型的对象，这是他们的表示，而不是他们的内容，被放在结果(所以字符串有引号，Unicode字符串是完全表示…)
• 使用类版本，您可以为需要的每个对象类型添加格式，或者为已经定义的对象类型更改它们。
• Key可以是任何有效类型。
• 缩进和换行符可以改变我们想要的一切。
• 字典，列表和元组都是打印出来的。

从这个链接:

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

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)

我使用某事的回答并稍微修改它，以适应我对嵌套字典和列表的需求:

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

然后输出如下:

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

我写了这段简单的代码，用Python打印json对象的一般结构。

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 + ']'

以下数据的结果

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)

非常紧凑，看起来像这样:

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

这里有一些东西可以打印任何类型的嵌套字典，同时跟踪“父”字典。

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)

这是一个好的起点，用于根据不同的格式进行打印，就像op中指定的那样。你真正需要做的只是围绕打印块进行操作。注意，它将查看该值是否为'OrderedDict()'。这取决于你是否使用了来自容器数据类型集合的东西，你应该做这些类型的故障保护，这样elif块不会因为它的名字而把它视为一个额外的字典。就像现在，一个例子字典

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

将打印

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

~修改代码以适应问题的格式~

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

使用相同的示例代码，它将打印以下内容:

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

这不是op中请求的完全。不同之处在于父元素^n仍然被打印，而不是不存在并被空白替换。为了得到OP的格式，你需要做如下的事情:迭代地比较dicList和lastDict。你可以通过创建一个新字典并将dicList的内容复制到它，检查复制的字典中的我是否与lastDict中的我相同，并且——如果是——使用字符串乘数函数将空白写入我位置。

正如其他人所发布的，你可以使用递归/dfs打印嵌套的字典数据，并递归调用如果它是一个字典;否则打印数据。

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

我只是在取某事的答案并做了一个小但非常有用的修改后回到这个问题。该函数打印该树中的所有JSON树中的键和叶节点大小。

def print_JSON_tree(d, indent=0):
for key, value in d.iteritems():
print '    ' * indent + unicode(key),
if isinstance(value, dict):
print; print_JSON_tree(value, indent+1)
else:
print ":", str(type(d[key])).split("'")[1], "-", str(len(unicode(d[key])))

当您有大型JSON对象并想要找出肉在哪里时，这非常好。例子:

>>> print_JSON_tree(JSON_object)
key1
value1 : int - 5
value2 : str - 16
key2
value1 : str - 34
value2 : list - 5623456

这将告诉你，你所关心的大部分数据可能都在JSON_object['key1']['key2']['value2']中，因为该值格式化为字符串的长度非常大。

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)

输出:

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

例如，撅嘴可以漂亮地打印你扔给它的任何东西(借用data从另一个答案):

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

将导致输出打印到屏幕上:

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

或者你可以返回对象的格式化字符串输出:

v = pout.s(data)

它的主要用途是调试，因此它不会阻塞对象实例或任何东西，它处理unicode输出，如你所期望的，在python 2.7和3中工作。

信息披露:我是pout的作者和维护者。

通过这种方式，你可以以漂亮的方式打印它，例如你的字典名是yasin

import json


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

或者,更安全:

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

使用这个函数:

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

这样叫它:

pretty_dict(mydict)

这是我在编写一个需要在.txt文件中编写字典的类时想到的:

@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

现在，如果我们有一个这样的字典:

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

我们这样做:

print(_pretty_write_dict(some_dict))

我们得到:

{
'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': '',
},
}

最python化的方法之一是使用已经构建的pprint模块。

定义打印深度所需的参数是depth

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

就是这样!

你可以使用print-dict

from print_dict import pd


dict1 = {
'key': 'value'
}


pd(dict1)

输出:

{
'key': 'value'
}

这 Python代码的输出:

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

安装:

$ pip install print-dict

信息披露:我是print-dict的作者

我还必须传递default参数，就像这样:

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

如果你想要键排序，你可以这样做:

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

为了修复此类型错误:

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

这是由于datetimes是字典中的一些值。

我尝试了以下方法，得到了我想要的结果

< >强方法1: 步骤1:在cmd

pip install print_dict

步骤2:导入print_dict as

from print_dict import pd

步骤3:使用pd打印

pd(your_dictionary_name)

示例输出:

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

< >强方法2: 我们还可以使用for循环，使用items方法

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

我用了你们教我的东西加上装饰器的力量来重载经典的打印功能。只要根据需要改变缩进即可。我将它作为要点添加到github中，以防你想要星号(保存)它。

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)

现在就像往常一样使用打印。

这里的现代解决方案是使用丰富的。安装与

pip install rich

使用as

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)

输出很好地缩进:

最简单的方法是安装IPython并使用如下所示的方法

from IPython.lib.pretty import pretty




class MyClass:
__repr__(self):
return pretty(data)  # replace data with what makes sense

在你的情况下

print(pretty(mydict))

prettyformatter

免责声明:我是该软件包的作者。

有关与其他格式化程序的比较，请参见其他格式器。

格式化

与pprint.pprint不同，prettyformatter更多地垂直扩展，并尝试更多地对齐项。

与json.dumps不同，prettyformatter通常更紧凑，并尝试在合理的地方对齐字典值。

from prettyformatter import pprint


batters = [
{"id": "1001", "type": "Regular"},
{"id": "1002", "type": "Chocolate"},
{"id": "1003", "type": "Blueberry"},
{"id": "1004", "type": "Devil's Food"},
]


toppings = [
{"id": "5001", "type": None},
{"id": "5002", "type": "Glazed"},
{"id": "5005", "type": "Sugar"},
{"id": "5007", "type": "Powdered Sugar"},
{"id": "5006", "type": "Chocolate with Sprinkles"},
{"id": "5003", "type": "Chocolate"},
{"id": "5004", "type": "Maple"},
]


data = {"id": "0001", "type": "donut", "name": "Cake", "ppu": 0.55, "batters": batters, "topping": toppings}


pprint(data)

输出:

{
"id"    : "0001",
"type"  : "donut",
"name"  : "Cake",
"ppu"   : 0.55,
"batters":
[
{"id": "1001", "type": "Regular"},
{"id": "1002", "type": "Chocolate"},
{"id": "1003", "type": "Blueberry"},
{"id": "1004", "type": "Devil's Food"},
],
"topping":
[
{"id": "5001", "type": None},
{"id": "5002", "type": "Glazed"},
{"id": "5005", "type": "Sugar"},
{"id": "5007", "type": "Powdered Sugar"},
{"id": "5006", "type": "Chocolate with Sprinkles"},
{"id": "5003", "type": "Chocolate"},
{"id": "5004", "type": "Maple"},
],
}

特性

完整的文档请参见在这里。

JSON

与pprint.pprint不同，prettyformatter支持通过json=True参数进行JSON转换。这包括将None更改为null， True更改为true， False更改为false，以及正确使用引号。

与json.dumps不同，prettyformatter支持更多数据类型的JSON强制转换。这包括将任何dataclass或mapping更改为dict，将任何iterable更改为list。

from dataclasses import dataclass


from prettyformatter import PrettyDataclass, pprint




@dataclass(unsafe_hash=True)
class Point(PrettyDataclass):
x: int
y: int




pprint((Point(1, 2), Point(3, 4)), json=True)

输出:

[{"x": 1, "y": 2}, {"x": 3, "y": 4}]

定制

与pprint.pprint或json.dumps不同，prettyformatter支持使用其他类型轻松定制。

为prettyformatter.PrettyClass子类实现__pargs__和/或__pkwargs__方法，可以方便地自定义"cls_name(*args, **kwargs)"形式的类。

from prettyformatter import PrettyClass




class Dog(PrettyClass):


def __init__(self, name, **kwargs):
self.name = name


def __pkwargs__(self):
return {"name": self.name}




print(Dog("Fido"))
"""
Dog(name="Fido")
"""


print(Dog("Fido"), json=True)
"""
{"name": "Fido"}
"""

实现__pformat__方法可以实现更具体的pformat函数。

实现@prettyformatter.register函数还允许以与实现__pformat__相同的方式自定义已经存在的类。

import numpy as np
from prettyformatter import pprint, register


@register(np.ndarray)
def pformat_ndarray(obj, specifier, depth, indent, shorten, json):
if json:
return pformat(obj.tolist(), specifier, depth, indent, shorten, json)
with np.printoptions(formatter=dict(all=lambda x: format(x, specifier))):
return repr(obj).replace("\n", "\n" + " " * depth)


pprint(dict.fromkeys("ABC", np.arange(9).reshape(3, 3)))

输出:

{
"A":
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]]),
"B":
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]]),
"C":
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]]),
}