Python-pprint大型dict很好吗？

我正在尝试打印一本相当大的字典，我想让它尽可能可读。尽管它看起来仍然不像我手动编写它的方式（需要时使用新行和缩进）

我正在尝试这样的格式（2个空格缩进）：

现在dict最初看起来是这样的（不使用pprint）：

使用：

pprint.pprint（my_dict）

，它看起来像：

{'stage': {'0.1.0': {'deploy': {'stage.com': {'inputs': [], 'outputs': []}},
                     'release': {'stage.git': {'inputs': [], 'outputs': []}}}},
 'test': {'0.1.0': {'deploy': {'some.host.com': {'inputs': [], 'outputs': []}},
                    'release': {'some.git': {'inputs': [], 'outputs': []}}},
          '0.2.0': {'deploy': {'some.host.com': {'inputs': [], 'outputs': []}},
                    'release': {'some.git': {'inputs': [], 'outputs': []}}}}}

嗯，没什么不同。我试着使用

pprint.pprint

选项，如

indent

，

width

，

compact

，但似乎没有一个能按我想要的方式格式化。是否可以像我上面提到的那样使用pprint实现类似的格式设置？或者有更好的工具

另外，如果您建议使用其他工具，也可以使用该工具写入文件，这将非常棒。因为我正在使用pprint直接写入文件。

使用

示例

>>> my_dict = {'test': {'0.2.0': {'deploy': {'some.host.com': {'outputs': [], 'inputs': []}},
   'release': {'some.git': {'outputs': [], 'inputs': []}}},
  '0.1.0': {'deploy': {'some.host.com': {'outputs': [], 'inputs': []}},
   'release': {'some.git': {'outputs': [], 'inputs': []}}}},
 'stage': {'0.1.0': {'deploy': {'stage.com': {'outputs': [], 'inputs': []}},
   'release': {'stage.git': {'outputs': [], 'inputs': []}}}}}... ... ... ... ...
>>>
>>> import json
>>> print(json.dumps(my_dict, indent=2))
{
  "test": {
    "0.2.0": {
      "deploy": {
        "some.host.com": {
          "outputs": [],
          "inputs": []
        }
      },
      "release": {
        "some.git": {
          "outputs": [],
          "inputs": []
        }
      }
    },
    "0.1.0": {
      "deploy": {
        "some.host.com": {
          "outputs": [],
          "inputs": []
        }
      },
      "release": {
        "some.git": {
          "outputs": [],
          "inputs": []
        }
      }
    }
  },
  "stage": {
    "0.1.0": {
      "deploy": {
        "stage.com": {
          "outputs": [],
          "inputs": []
        }
      },
      "release": {
        "stage.git": {
          "outputs": [],
          "inputs": []
        }
      }
    }
  }
}

你可以用它来做

---

有点古怪，而且没有赢得任何推广到其他问题的定价（虽然可以通过一些努力来修正），但是你也可以考虑类似的事情。它将打印比json格式更紧凑的结果：

d = {'test': {'0.2.0': {'deploy': {'some.host.com': {'outputs': [], 'inputs': []}},
   'release': {'some.git': {'outputs': [], 'inputs': []}}},
  '0.1.0': {'deploy': {'some.host.com': {'outputs': [], 'inputs': []}},
   'release': {'some.git': {'outputs': [], 'inputs': []}}}},
 'stage': {'0.1.0': {'deploy': {'stage.com': {'outputs': [], 'inputs': []}},
   'release': {'stage.git': {'outputs': [], 'inputs': []}}}}}

print(pd.DataFrame({
    (i,j, k, l, m): str(d[i][j][k][l][m])
    for i in d.keys() 
    for j in d[i].keys() 
    for k in d[i][j].keys() 
    for l in d[i][j][k].keys() 
    for m in d[i][j][k][l].keys()
}, index = [0]
).T

---

我也需要它，对原始的

pprint

不满意。 具体来说，我希望它能够正常缩进（2或4个空格），而不是像

pprint

那样缩进

具体来说，对于某些dict，我使用原始的

pprint

获得了这个输出：

  {'melgan': {'class': 'subnetwork',
              'from': 'data',
              'subnetwork': {'l0': {'axes': 'spatial',
                                    'class': 'pad',
                                    'from': 'data',
                                    'mode': 'reflect',
                                    'padding': (3, 3)},
                             'la1': {'activation': None,
                                     'class': 'conv',
                                     'dilation_rate': (1,),
                                     'filter_size': (7,),
                                     'from': 'l0',
                                     'n_out': 384,
                                     'padding': 'valid',
                                     'strides': (1,),
                                     'with_bias': True},
                             'lay2': {'class': 'eval',
                                      'eval': 'tf.nn.leaky_relu(source(0), '
                                              'alpha=0.2)',
                                      'from': 'la1'},
                             'layer3_xxx': {'activation': None,
                                            'class': 'transposed_conv',
                                            'filter_size': (10,),
                                            'from': 'lay2',
                                            'n_out': 192,
                                            'output_padding': (1,),
                                            'padding': 'valid',
                                            'remove_padding': (3,),
                                            'strides': (5,),
                                            'with_bias': True},
                             'output': {'class': 'copy', 'from': 'layer3_xxx'}}},
   'output': {'class': 'copy', 'from': 'melgan'}}

但我希望它是这样的：

  {
    'melgan': {
      'class': 'subnetwork',
      'from': 'data',
      'subnetwork': {
        'l0': {'class': 'pad', 'mode': 'reflect', 'axes': 'spatial', 'padding': (3, 3), 'from': 'data'},
        'la1': {
          'class': 'conv',
          'from': 'l0',
          'activation': None,
          'with_bias': True,
          'n_out': 384,
          'filter_size': (7,),
          'padding': 'valid',
          'strides': (1,),
          'dilation_rate': (1,)
        },
        'lay2': {'class': 'eval', 'eval': 'tf.nn.leaky_relu(source(0), alpha=0.2)', 'from': 'la1'},
        'layer3_xxx': {
          'class': 'transposed_conv',
          'from': 'lay2',
          'activation': None,
          'with_bias': True,
          'n_out': 192,
          'filter_size': (10,),
          'strides': (5,),
          'padding': 'valid',
          'output_padding': (1,),
          'remove_padding': (3,)
        },
        'output': {'class': 'copy', 'from': 'layer3_xxx'}
      }
    },
    'output': {'class': 'copy', 'from': 'melgan'}
  }

还有，它还提供了自己的

pprint

变体（

from rich.pretty import pprint

），接近我想要的

还有，这也很接近

我实现了一个非常简单的变体。代码：

从键入import Any
导入系统
进口numpy
def pprint（o:Any，*，file=sys.stdout，
前缀=”，后缀=”，
行前缀=”，行后缀=”\n“->无：
如果第\u行后缀和第\u类型\u简单性\u分数（o）str中有“\n”：
输入io
s=io.StringIO（）
pprint（o，文件=s）
返回s.getvalue（）
_类型简单性限制=120.#幻数
定义类型简单性分数（o:Any，_offset=0.）->浮点：
"""
：param Any o:
：参数浮动_偏移：
：return：一个分数，它是对len（repr（o））的一个非常粗略的估计，可以有效地计算
"""
_间距=2。
如果存在（o，布尔）：
返回4+_抵消
如果isinstance（o，（int，numpy.integer））：
如果o==0：
返回1+_抵消
返回1+numpy.log10（abs（o））+u偏移量
如果存在（o，str）：
返回2+len（o）+_偏移量
如果isinstance（o，（浮点，复数，numpy.number））：
返回len（repr（o））+\u偏移量
如果isinstance（o，（元组、列表、集合））：
对于o中的x：
_偏移量=\类型\简单性\分数（x，\偏移量=\偏移量+\间距）
如果偏移量>类型限制：
打破
返回偏移量
如果存在（o，dict）：
对于o.values（）中的x:#忽略键。。。
_偏移量=_类型_简单性_分数（x，_偏移量=_偏移量+10.+_间距）#+10用于键
如果偏移量>类型限制：
打破
返回偏移量
如果存在（o，numpy.ndarray）：
_偏移量+=10#前缀/后缀
如果o.尺寸*2+_偏移量>\类型\简单性\限制：\已经太大了？
返回o.size*2+_抵消
如果str（o.dtype）.startswith（“int”）：
a=\类型\简单性\分数（numpy.max（numpy.abs（o））+\间距
返回o.size*a+\U偏移量
a=最大值（[_type_simplicity_score（x）表示x在o.flatte（）中的分数]）+_间距
返回o.size*a+\U偏移量
#未知物体。回退>\类型\简单性\限制。
返回类型简单限制+1+_抵消

你的P.S改变了这个问题，在我看来，你想使用

pickle

或

json

这样的东西，因为你是想把“易读”版本写到文件中，还是任何基于文本的版本？你想打印（json.dumps（data，indent=2））？谢谢，看起来好多了：）如果我的dict中的值包含非JSON可序列化变量，这就不起作用。只有在字典没有Python对象（如

datetime

type）时，才能使用此解决方案，否则会出现错误，例如

TypeError:datetime类型的对象不是JSON可序列化的

d = {'test': {'0.2.0': {'deploy': {'some.host.com': {'outputs': [], 'inputs': []}},
   'release': {'some.git': {'outputs': [], 'inputs': []}}},
  '0.1.0': {'deploy': {'some.host.com': {'outputs': [], 'inputs': []}},
   'release': {'some.git': {'outputs': [], 'inputs': []}}}},
 'stage': {'0.1.0': {'deploy': {'stage.com': {'outputs': [], 'inputs': []}},
   'release': {'stage.git': {'outputs': [], 'inputs': []}}}}}

print(pd.DataFrame({
    (i,j, k, l, m): str(d[i][j][k][l][m])
    for i in d.keys() 
    for j in d[i].keys() 
    for k in d[i][j].keys() 
    for l in d[i][j][k].keys() 
    for m in d[i][j][k][l].keys()
}, index = [0]
).T

  {'melgan': {'class': 'subnetwork',
              'from': 'data',
              'subnetwork': {'l0': {'axes': 'spatial',
                                    'class': 'pad',
                                    'from': 'data',
                                    'mode': 'reflect',
                                    'padding': (3, 3)},
                             'la1': {'activation': None,
                                     'class': 'conv',
                                     'dilation_rate': (1,),
                                     'filter_size': (7,),
                                     'from': 'l0',
                                     'n_out': 384,
                                     'padding': 'valid',
                                     'strides': (1,),
                                     'with_bias': True},
                             'lay2': {'class': 'eval',
                                      'eval': 'tf.nn.leaky_relu(source(0), '
                                              'alpha=0.2)',
                                      'from': 'la1'},
                             'layer3_xxx': {'activation': None,
                                            'class': 'transposed_conv',
                                            'filter_size': (10,),
                                            'from': 'lay2',
                                            'n_out': 192,
                                            'output_padding': (1,),
                                            'padding': 'valid',
                                            'remove_padding': (3,),
                                            'strides': (5,),
                                            'with_bias': True},
                             'output': {'class': 'copy', 'from': 'layer3_xxx'}}},
   'output': {'class': 'copy', 'from': 'melgan'}}

  {
    'melgan': {
      'class': 'subnetwork',
      'from': 'data',
      'subnetwork': {
        'l0': {'class': 'pad', 'mode': 'reflect', 'axes': 'spatial', 'padding': (3, 3), 'from': 'data'},
        'la1': {
          'class': 'conv',
          'from': 'l0',
          'activation': None,
          'with_bias': True,
          'n_out': 384,
          'filter_size': (7,),
          'padding': 'valid',
          'strides': (1,),
          'dilation_rate': (1,)
        },
        'lay2': {'class': 'eval', 'eval': 'tf.nn.leaky_relu(source(0), alpha=0.2)', 'from': 'la1'},
        'layer3_xxx': {
          'class': 'transposed_conv',
          'from': 'lay2',
          'activation': None,
          'with_bias': True,
          'n_out': 192,
          'filter_size': (10,),
          'strides': (5,),
          'padding': 'valid',
          'output_padding': (1,),
          'remove_padding': (3,)
        },
        'output': {'class': 'copy', 'from': 'layer3_xxx'}
      }
    },
    'output': {'class': 'copy', 'from': 'melgan'}
  }

from typing import Any
import sys
import numpy


def pprint(o: Any, *, file=sys.stdout,
           prefix="", postfix="",
           line_prefix="", line_postfix="\n") -> None:
  if "\n" in line_postfix and _type_simplicity_score(o) <= _type_simplicity_limit:
    prefix = f"{line_prefix}{prefix}"
    line_prefix = ""
    postfix = postfix + line_postfix
    line_postfix = ""

  def _sub_pprint(o: Any, prefix="", postfix="", inc_indent=True):
    multi_line = "\n" in line_postfix
    if not multi_line and postfix.endswith(","):
      postfix += " "
    pprint(
      o, file=file, prefix=prefix, postfix=postfix,
      line_prefix=(line_prefix + "  " * inc_indent) if multi_line else "",
      line_postfix=line_postfix)

  def _print(s: str, is_end: bool = False):
    nonlocal prefix  # no need for is_begin, just reset prefix
    file.write(line_prefix)
    file.write(prefix)
    file.write(s)
    if is_end:
      file.write(postfix)
    file.write(line_postfix)
    if "\n" in line_postfix:
      file.flush()
    prefix = ""

  def _print_list():
    for i, v in enumerate(o):
      _sub_pprint(v, postfix="," if i < len(o) - 1 else "")

  if isinstance(o, list):
    if len(o) == 0:
      _print("[]", is_end=True)
      return
    _print("[")
    _print_list()
    _print("]", is_end=True)
    return

  if isinstance(o, tuple):
    if len(o) == 0:
      _print("()", is_end=True)
      return
    if len(o) == 1:
      _sub_pprint(o[0], prefix=f"{prefix}(", postfix=f",){postfix}", inc_indent=False)
      return
    _print("(")
    _print_list()
    _print(")", is_end=True)
    return

  if isinstance(o, set):
    if len(o) == 0:
      _print("set()", is_end=True)
      return
    _print("{")
    _print_list()
    _print("}", is_end=True)
    return

  if isinstance(o, dict):
    if len(o) == 0:
      _print("{}", is_end=True)
      return
    _print("{")
    for i, (k, v) in enumerate(o.items()):
      _sub_pprint(v, prefix=f"{k!r}: ", postfix="," if i < len(o) - 1 else "")
    _print("}", is_end=True)
    return

  if isinstance(o, numpy.ndarray):
    _sub_pprint(
      o.tolist(),
      prefix=f"{prefix}numpy.array(",
      postfix=f", dtype=numpy.{o.dtype}){postfix}",
      inc_indent=False)
    return

  # fallback
  _print(repr(o), is_end=True)


def pformat(o: Any) -> str:
  import io
  s = io.StringIO()
  pprint(o, file=s)
  return s.getvalue()


_type_simplicity_limit = 120.  # magic number


def _type_simplicity_score(o: Any, _offset=0.) -> float:
  """
  :param Any o:
  :param float _offset:
  :return: a score, which is a very rough estimate of len(repr(o)), calculated efficiently
  """
  _spacing = 2.
  if isinstance(o, bool):
    return 4. + _offset
  if isinstance(o, (int, numpy.integer)):
    if o == 0:
      return 1. + _offset
    return 1. + numpy.log10(abs(o)) + _offset
  if isinstance(o, str):
    return 2. + len(o) + _offset
  if isinstance(o, (float, complex, numpy.number)):
    return len(repr(o)) + _offset
  if isinstance(o, (tuple, list, set)):
    for x in o:
      _offset = _type_simplicity_score(x, _offset=_offset + _spacing)
      if _offset > _type_simplicity_limit:
        break
    return _offset
  if isinstance(o, dict):
    for x in o.values():  # ignore keys...
      _offset = _type_simplicity_score(x, _offset=_offset + 10. + _spacing)  # +10 for key
      if _offset > _type_simplicity_limit:
        break
    return _offset
  if isinstance(o, numpy.ndarray):
    _offset += 10.  # prefix/postfix
    if o.size * 2. + _offset > _type_simplicity_limit:  # too big already?
      return o.size * 2. + _offset
    if str(o.dtype).startswith("int"):
      a = _type_simplicity_score(numpy.max(numpy.abs(o))) + _spacing
      return o.size * a + _offset
    a = max([_type_simplicity_score(x) for x in o.flatten()]) + _spacing
    return o.size * a + _offset
  # Unknown object. Fallback > _type_simplicity_limit.
  return _type_simplicity_limit + 1. + _offset