중첩된 사전을 예쁘게 인쇄하는 방법
Python에서는 어떻게 하면 깊이 ~4의 사전을 예쁘게 인쇄할 수 있을까요?pprint()이치노
import pprint
pp = pprint.PrettyPrinter(indent=4)
pp.pprint(mydict)
는 단지움푹 패인 것을 ."\t"틀
key1
value1
value2
key2
value1
value2
기타.
이거 어떻게 해?
처음에는 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.items():
print('\t' * indent + str(key))
if isinstance(value, dict):
pretty(value, indent+1)
else:
print('\t' * (indent+1) + 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
이렇게 하면 예를 들어 사전 이름이 다음과 같이 예쁘게 인쇄할 수 있습니다.yasin
import json
print (json.dumps(yasin, indent=2))
또는 보다 안전합니다.
print (json.dumps(yasin, indent=2, default=str))
가장 중요한 방법 중 하나는 이미 빌드된 pprint 모듈을 사용하는 것입니다.
를 정의하기 입니다.depth
import pprint
pp = pprint.PrettyPrinter(depth=4)
pp.pprint(mydict)
바로 그거야!
지금까지의 작업에서는, 파이썬 인터프리터의 출력을 적어도 매우 간단한 포맷으로 모방한 예쁜 프린터는 보이지 않습니다.그래서 제 프린터는 다음과 같습니다.
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 문자열이 완전히 표현됩니다).
- 클래스 버전에서는 원하는 모든 개체 유형에 대한 형식을 추가하거나 이미 정의된 개체 유형에 대해 형식을 변경할 수 있습니다.
- 키는 모든 유효한 유형입니다.
- 들여쓰기 및 줄바꿈 문자를 원하는 대로 변경할 수 있습니다.
- 딕트, 리스트, 튜플은 인쇄가 잘 되어 있습니다.
는 합격하지 안 .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
날짜 시간이 사전의 일부 값이기 때문에 발생합니다.
의 다른 옵션:
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]
}
}
여기서의 현대적인 해결책은 리치(Rich)를 사용하는 것이다.인스톨
pip install rich
로서 사용하다
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)
출력은, 다음과 같이 들여쓰기되어 있습니다.
사용할 수 있습니다.
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
다른 사용자가 게시한 것처럼 재귀/dfs를 사용하여 중첩된 사전 데이터를 인쇄하고 사전인 경우 재귀 호출할 수 있습니다. 그렇지 않은 경우 데이터를 인쇄할 수 있습니다.
def print_json(data):
if type(data) == dict:
for k, v in data.items():
print k
print_json(v)
else:
print data
예를 들어, pout은 당신이 던지는 모든 것을 인쇄할 수 있습니다.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)
주요 사용 사례는 디버깅을 위한 것으로, 오브젝트 인스턴스나 그 어떤 것에 대해서도 초크하지 않고, 예상대로 유니코드 출력을 처리하며, python 2.7 및 3에서 동작합니다.
공개:저는 poup의 작가이자 관리자입니다.
나는 어떤 사람의 답변을 내배된 사전과 목록에 맞게 약간 중첩된 사전과거:
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
...
너희들이 가르쳐준 거랑 장식가의 힘을 사용해서 고전적인 프린트 기능을 과부하시켰어계약서를 필요에 맞게 변경하세요.staring(저장)을 원하실 경우를 대비해서 github에 gist로 추가했습니다.
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)
인쇄를 평상시와 같이 사용합니다.
파이썬에서 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'):
}
나는 다음을 시도했고 원하는 결과를 얻었다.
방법 1: 순서 1: 설치print_dict에 cmd
pip install print_dict
순서 2: print_dict를 Import 합니다.
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}")
뭔가, 예쁘네요;)
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)))
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)
저는 어떤 사람의 답변을 듣고 작지만 매우 유용한 수정을 한 후에 이 질문으로 돌아갑니다.이 함수는 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']문자열로 포맷된 값의 길이가 매우 크기 때문입니다.
가장 쉬운 방법은 IPython을 설치하고 다음과 같은 것을 사용하는 것입니다.
from IPython.lib.pretty import pretty
class MyClass:
__repr__(self):
return pretty(data) # replace data with what makes sense
고객님의 경우
print(pretty(mydict))
저는 비교적 초보적인 비단뱀이지만 지난 몇 주 동안 중첩된 사전을 연구해 왔고 이것이 제가 생각해낸 것입니다.
스택을 사용해 보세요.루트 딕셔너리의 키를 목록으로 만듭니다.
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.dumps와 동일하게 동작하지만 들여쓰기에 공백이 아닌 탭을 사용하고 있습니다.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"
}
}
여기 "부모" 사전을 추적하면서 중첩된 사전을 인쇄할 수 있는 무언가가 있습니다.
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()'이 그것을 보는 것 같습니다.당신이 컨테이너 datatypes 모음에서 뭔가 사용 중에 따라, 당신 fail-safes 이런 종류의 그래서 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']
~altering 코드는 질문의 format~에 맞는 것.
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
이지 정확히 관측소에서 요구된다 있다.그 차이점은 parent^n 여전히, 대신 대 결석한과 white-space로 교체 인쇄되어 있다.OP의 형식에 도달하려면 아래와 같은 것을 할:반복적으로 그 lastDict과 dicList 비교하야 합니다.당신과 그것에 dicList의 내용 복사, 만약 내 복사한 사전에 그 목화로lastDict에서 동일하다 검사하여, 그리고, 만약 그것은 그것에 나는 문자열 상승 기능을 사용하여다면 공간을 좀 많이 띄워라를 쓰고 새 사전을 만듦으로써 이것을 할 수 있다.
이 링크에서:
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 ' ', 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(' ',' ')
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>{
'C' :2,
'B' :1,
'E' :4,
(3, 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]
}
'''
이 기능을 사용하세요:
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': '',
},
}
프리포메터
면책사항:제가 패키지 제작자입니다.
다른 포맷터와의 비교는 기타 포맷터를 참조하십시오.
포맷
와는 달리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 변환을 지원합니다.json=True논쟁.여기에는 변경도 포함됩니다.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는, 추가 타입으로 간단하게 커스터마이즈 할 수 있습니다.
의 실장__pargs__및/또는__pkwargs__의 방법prettyformatter.PrettyClass하면, 「클래스는 커스터마이즈 할 수 있습니다」라고 하는 형식으로 할 수 ."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]]),
}
언급URL : https://stackoverflow.com/questions/3229419/how-to-pretty-print-nested-dictionaries
'programing' 카테고리의 다른 글
| Java 날짜 및 시간 클래스를 사용할까요, 아니면 Joda Time과 같은 서드파티 라이브러리를 사용할까요? (0) | 2022.09.22 |
|---|---|
| Java 8: 람다의 반복 횟수를 세는 데 선호되는 방법? (0) | 2022.09.22 |
| MySQL: GROUP_CONCAT(왼쪽 결합 포함) (0) | 2022.09.21 |
| 두 날짜 사이의 데이터 프레임 행 선택 (0) | 2022.09.21 |
| MySQL: 플로트와 더블의 차이점은 무엇입니까? (0) | 2022.09.21 |