我有一个大字典，我打印用漂亮的图片查看，但我如何保持格式化但在pprint中杀掉排序机制？
答案 0 :(得分：6)
您可以monkey patch pprint模块。
import pprint
pprint.pprint({"def":2,"ghi":3,"abc":1,})
pprint._sorted = lambda x:x
# Or, for Python 3.7:
# pprint.sorted = lambda x, key=None: x
pprint.pprint("def":2,"ghi":3, "abc":1})
由于第二个输出基本上是随机排序的，因此您的输出可能与我的输出不同：
{'abc': 1, 'def': 2, 'ghi': 3}
{'abc': 1, 'ghi': 3, 'def': 2}
<小时/> 另一个版本更复杂，但更易于使用：
import pprint
import contextlib
@contextlib.contextmanager
def pprint_nosort():
# Note: the pprint implementation changed somewhere
# between 2.7.12 and 3.7.0. This is the danger of
# monkeypatching!
try:
# Old pprint
orig,pprint._sorted = pprint._sorted, lambda x:x
except AttributeError:
# New pprint
import builtins
orig,pprint.sorted = None, lambda x, key=None:x
try:
yield
finally:
if orig:
pprint._sorted = orig
else:
del pprint.sorted
# For times when you don't want sorted output
with pprint_nosort():
pprint.pprint({"def":2,"ghi":3, "abc":1})
# For times when you do want sorted output
pprint.pprint({"def":2,"ghi":3, "abc":1})
答案 1 :(得分：3)
从Python 3.8开始，您can finally disable this。请注意，自Python 3.7起（实际上，甚至自3.6起），字典都是按插入顺序排列的。
import pprint
data = {'not': 'sorted', 'awesome': 'dict', 'z': 3, 'y': 2, 'x': 1}
pprint.pprint(data, sort_dicts=False)
# prints {'not': 'sorted', 'awesome': 'dict', 'z': 3, 'y': 2, 'x': 1}
或者，创建一个pretty printer object：
pp = pprint.PrettyPrinter(sort_dicts=False)
pp.pprint(data)
这不影响集合（仍在排序中），但是集合没有插入顺序保证。
答案 2 :(得分：1)
您可以继承PrettyPrinter并从sorted(object.items())中删除_pprint_dict。
注意：这段代码是Python 3.5 +
# unsorted_pprint.py
from pprint import PrettyPrinter, _builtin_scalars, _recursion
__all__ = [
'UnsortedPrettyPrinter',
'pprint2',
'pformat2',
]
class UnsortedPrettyPrinter(PrettyPrinter):
"""Pretty printer that retains original dict ordering
"""
def __init__(self, *args, **kwargs):
super().__init__()
self._dispatch = {
**self._dispatch,
dict.__repr__: self._pprint_dict,
}
@staticmethod
def _pprint_dict(self, object, stream, indent, allowance, context, level):
write = stream.write
write('{')
if self._indent_per_level > 1:
write((self._indent_per_level - 1) * ' ')
length = len(object)
if length:
items = object.items()
self._format_dict_items(items, stream, indent, allowance + 1,
context, level)
write('}')
def format(self, object, context, maxlevels, level):
"""Format object for a specific context, returning a string
and flags indicating whether the representation is 'readable'
and whether the object represents a recursive construct.
"""
return self._safe_repr(object, context, maxlevels, level)
def _safe_repr(self, object, context, maxlevels, level):
typ = type(object)
if typ in _builtin_scalars:
return repr(object), True, False
r = getattr(typ, "__repr__", None)
if issubclass(typ, dict) and r is dict.__repr__:
if not object:
return "{}", True, False
objid = id(object)
if maxlevels and level >= maxlevels:
return "{...}", False, objid in context
if objid in context:
return _recursion(object), False, True
context[objid] = 1
readable = True
recursive = False
components = []
append = components.append
level += 1
saferepr = self._safe_repr
items = object.items()
for k, v in items:
krepr, kreadable, krecur = saferepr(k, context, maxlevels, level)
vrepr, vreadable, vrecur = saferepr(v, context, maxlevels, level)
append("%s: %s" % (krepr, vrepr))
readable = readable and kreadable and vreadable
if krecur or vrecur:
recursive = True
del context[objid]
return "{%s}" % ", ".join(components), readable, recursive
if (issubclass(typ, list) and r is list.__repr__) or \
(issubclass(typ, tuple) and r is tuple.__repr__):
if issubclass(typ, list):
if not object:
return "[]", True, False
format = "[%s]"
elif len(object) == 1:
format = "(%s,)"
else:
if not object:
return "()", True, False
format = "(%s)"
objid = id(object)
if maxlevels and level >= maxlevels:
return format % "...", False, objid in context
if objid in context:
return _recursion(object), False, True
context[objid] = 1
readable = True
recursive = False
components = []
append = components.append
level += 1
for o in object:
orepr, oreadable, orecur = self._safe_repr(o, context, maxlevels, level)
append(orepr)
if not oreadable:
readable = False
if orecur:
recursive = True
del context[objid]
return format % ", ".join(components), readable, recursive
rep = repr(object)
return rep, (rep and not rep.startswith('<')), False
def pprint2(object, stream=None, indent=1, width=80, depth=None, *,
compact=False):
"""Pretty-print a Python object to a stream [default is sys.stdout].
dict items are left unsorted.
"""
printer = UnsortedPrettyPrinter(
stream=stream,
indent=indent,
width=width,
depth=depth,
compact=compact,
)
printer.pprint(object)
def pformat2(object, indent=1, width=80, depth=None, *, compact=False):
"""Format a Python object into a pretty-printed representation.
dict items are left unsorted.
"""
return UnsortedPrettyPrinter(
indent=indent,
width=width,
depth=depth,
compact=compact,
).pformat(object)
答案 3 :(得分：0)
我知道我来晚了一点，但是我禁用排序字典的首选方法是使用partial：
from functools import partial
from pprint import pprint
pprint = partial(pprint, sort_dicts=False)
我个人喜欢这种方式，因为它引入了最小的差异。
猴子修补的好处在于，您只需在一个位置进行更改（与其他选项不同），而不必弄乱pprint的内部。
我正在使用py3.8，但是无论何时添加sort_dicts选项，它都应该起作用。