标准库：pprint --- 数据美化输出

最新推荐文章于 2024-05-23 09:42:50 发布

hd51cc

最新推荐文章于 2024-05-23 09:42:50 发布

阅读量714

点赞数

分类专栏： Python 文章标签： pprint模块美化打印 Python数据结构 PrettyPrinter类输出格式化

本文链接：https://blog.csdn.net/hd51cc/article/details/124054870

版权

Python 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

Lib/pprint.py

pprint 模块提供了“美化打印”任意 Python 数据结构的功能，这种美化形式可用作对解释器的输入。如果经格式化的结构包含非基本 Python 类型的对象，则其美化形式可能无法被加载。包含文件、套接字或类对象，以及许多其他不能用 Python 字面值来表示的对象都有可能导致这样的结果。

pprint 模块定义了一个类：

class pprint.PrettyPrinter(indent=1, width=80, depth=None, stream=None, *, compact=False, sort_dicts=True, underscore_numbers=False)

stream (默认为 sys.stdout) 是一个 file-like object，通过调用该对象的 write() 方法可以将输出写入其中。
indent (默认为 1) 指定要为每个缩进层级添加的缩进量。
depth 控制可被打印的缩进层级数量；如果要打印的数据结构层级过深，则其所包含的下一层级将用 ... 替换。默认情况下，对于被格式化对象的层级深度没有任何限制。
width (默认为 80) 指定输出中每行所允许的最大字符数。如果一个数据结构无法在宽度限制之内被格式化，将显示尽可能多的内容。
compact 影响长序列（列表、元组、集合等等）的格式化方式。如果 compact 为假值（默认）则序列的每一项将格式化为单独的行。如果 compact 为真值，则每个输出行格式化时将在 width 的限制之内尽可能地容纳多个条目。
如果 sort_dicts 为真值（默认），字典在格式化时将基于键进行排序，否则它们将按插入顺序显示。
如果 underscore_numbers 为真值，整数在格式化时将使用 _ 字符作为千位分隔符，否则不显示下划线（默认）。

import pprint
stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']
for s in stuff[:]:
    stuff.insert(0, s)

pp=pprint.PrettyPrinter(indent=1)
pp.pprint(stuff)
# output:
# ['ni',
#  'knights',
#  'lumberjack',
#  'eggs',
#  'spam',
#  'spam',
#  'eggs',
#  'lumberjack',
#  'knights',
#  'ni']

pp=pprint.PrettyPrinter(indent=10)
pp.pprint(stuff)
# output:
# [         'ni',
#           'knights',
#           'lumberjack',
#           'eggs',
#           'spam',
#           'spam',
#           'eggs',
#           'lumberjack',
#           'knights',
#           'ni']

import pprint

tup = ('spam', ('eggs', ('lumberjack', ('knights', ('ni', ('dead', ('parrot', ('fresh fruit',))))))))

pp = pprint.PrettyPrinter(width=1, depth=None)
pp.pprint(tup)
# output:
# ('spam',
#  ('eggs',
#   ('lumberjack',
#    ('knights',
#     ('ni',
#      ('dead',
#       ('parrot',
#        ('fresh '
#         'fruit',))))))))

pp = pprint.PrettyPrinter(width=80, depth=None)
pp.pprint(tup)
# output:
# ('spam',
#  ('eggs',
#   ('lumberjack', ('knights', ('ni', ('dead', ('parrot', ('fresh fruit',))))))))

pp = pprint.PrettyPrinter(width=80, depth=4)
pp.pprint(tup)
# output:
# ('spam', ('eggs', ('lumberjack', ('knights', (...)))))

import pprint

num = 123456789000000000

pp = pprint.PrettyPrinter(underscore_numbers=False)
pp.pprint(num)
# output:123456789000000000

pp = pprint.PrettyPrinter(underscore_numbers=True)
pp.pprint(num)
# output:123_456_789_000_000_000

import pprint

str1 = '123456789000000000'
list1 = [str1]*2
pp = pprint.PrettyPrinter(width=30)
pp.pprint(list1)
# output:
# ['123456789000000000',
#  '123456789000000000']

pp = pprint.PrettyPrinter(width=60)
pp.pprint(list1)
# output:
# ['123456789000000000','123456789000000000']

import pprint

str1 = '123'
str2 = '456'
str3 = '789'
str4 = '123456'
str4 = '123456789'
list1 = [str1, str2, str3, str4]
pp = pprint.PrettyPrinter( width=30, compact=False)
pp.pprint(list1)
# output:
# ['123',
#  '456',
#  '789',
#  '123456789']

pp = pprint.PrettyPrinter(width=30, compact=True)
pp.pprint(list1)
# output:
# ['123',
#  '456',
#  '789',
#  '123456789']

import pprint

dict1 = {'abc': '123'}
dict1['def'] = '456'
dict1['bcd'] = '234'
dict1['cde'] = '345'

pp = pprint.PrettyPrinter(sort_dicts=True)
pp.pprint(dict1)
# output:{'abc': '123', 'bcd': '234', 'cde': '345', 'def': '456'}

pp = pprint.PrettyPrinter(sort_dicts=False)
pp.pprint(dict1)
# output:{'abc': '123', 'def': '456', 'bcd': '234', 'cde': '345'}

pprint.pformat(object, indent=1, width=80, depth=None, *, compact=False, sort_dicts=True, underscore_numbers=False)

将 object 的格式化表示作为字符串返回。 indent, width, depth, compact, sort_dicts 和 underscore_numbers 将作为格式化形参传递给 PrettyPrinter 构造器。

import pprint

num = 123456789000000000
print(pprint.pformat(num, underscore_numbers=False))
# output:123456789000000000

print(pprint.pformat(num, underscore_numbers=True))
# output:123_456_789_000_000_000

pprint.pp(object, *args, sort_dicts=False, **kwargs)

打印 object 的格式化表示并附带一个换行符。如果 sort_dicts 为假值（默认），字典将按键的插入顺序显示，否则将按字典键排序。 args 和 kwargs 将作为格式化形参被传给 pprint()。

import pprint

dict1 = {'abc': '123'}
dict1['def'] = '456'
dict1['bcd'] = '234'
dict1['cde'] = '345'

print(pprint.pp(dict1,sort_dicts=False))
# output:{'abc': '123', 'def': '456', 'bcd': '234', 'cde': '345'}
# output:None
print(pprint.pp(dict1,sort_dicts=True))
# output:{'abc': '123', 'bcd': '234', 'cde': '345', 'def': '456'}
# output:None

pprint.pprint(object, stream=None, indent=1, width=80, depth=None, *, compact=False, sort_dicts=True, underscore_numbers=False)

将 object 的格式化表示打印至 stream，末尾带一个换行符。如果 stream 为 None，则使用 sys.stdout。这可在交互式解释器而非 print() 函数中使用以便对值进行检查（你甚至可以在特定作用域内重赋值 print = pprint.pprint 以方便使用）。 indent, width, depth, compact, sort_dicts 和 underscore_numbers 将作为格式化形参传递给 PrettyPrinter 构造器。

import pprint

dict1 = {'abc': '123'}
dict1['def'] = '456'
dict1['bcd'] = '234'
dict1['cde'] = '345'

pprint.pprint(dict1, sort_dicts=False)
# output:{'abc': '123', 'def': '456', 'bcd': '234', 'cde': '345'}

pprint.pprint(dict1, sort_dicts=True)
# output:{'abc': '123', 'bcd': '234', 'cde': '345', 'def': '456'}

pprint.isreadable(object)

确定 object 的格式化表示是否“可读”，或是否可被用来通过 eval() 重新构建对象的值。此函数对于递归对象总是返回 False。

import pprint

stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']
pp = pprint.PrettyPrinter(sort_dicts=True)
pp.pprint(pprint.isreadable(stuff))
# output: True

pprint.isrecursive(object)

确定 object 是否需要递归表示。

import pprint

stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']
pp = pprint.PrettyPrinter(sort_dicts=True)
pp.pprint(pprint.isrecursive(stuff))
# output: False

pprint.saferepr(object)

返回 object 的字符串表示，并为递归数据结构提供保护。

如果 object 的表示形式公开了一个递归条目，该递归引用会被表示为 <Recursion on typename with id=number>。该表示因而不会进行其它格式化。

import pprint

stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']
pp = pprint.PrettyPrinter(sort_dicts=True)
pp.pprint(pprint.saferepr(stuff))
# output: "['spam', 'eggs', 'lumberjack', 'knights', 'ni']"

PrettyPrinter 对象

PrettyPrinter.pformat(object)

返回 object 格式化表示。这会将传给 PrettyPrinter 构造器的选项纳入考虑。

import pprint

num = 123456789000000000

pp = pprint.PrettyPrinter(underscore_numbers=False)
print(pp.pformat(num))
# output:123456789000000000

pp = pprint.PrettyPrinter(underscore_numbers=True)
print(pp.pformat(num))
# output:123_456_789_000_000_000

PrettyPrinter.pprint(object)

在所配置的流上打印 object 的格式化表示，并附加一个换行符。

下列方法提供了与同名函数相对应的实现。在实例上使用这些方法效率会更高一些，因为不需要创建新的 PrettyPrinter 对象。

import pprint

num = 123456789000000000

pp = pprint.PrettyPrinter(underscore_numbers=False)
pp.pprint(num)
# output:123456789000000000

pp = pprint.PrettyPrinter(underscore_numbers=True)
pp.pprint(num)
# output:123_456_789_000_000_000

PrettyPrinter.isreadable(object)

确定对象的格式化表示是否“可读”，或者是否可使用 eval() 重建对象值。请注意此方法对于递归对象将返回 False。如果设置了 PrettyPrinter 的 depth 形参并且对象深度超出允许范围，此方法将返回 False。

import pprint

num = 123456789000000000

pp = pprint.PrettyPrinter(underscore_numbers=False)
print(pp.isreadable(num))
# output:True

PrettyPrinter.isrecursive(object)

确定对象是否需要递归表示。

import pprint

num = 123456789000000000

pp = pprint.PrettyPrinter(underscore_numbers=False)
print(pp.isrecursive(num))
# output:False

PrettyPrinter.format(object, context, maxlevels, level)

返回三个值：字符串形式的 object 已格式化版本，指明结果是否可读的旗标，以及指明是否检测到递归的旗标。

第一个参数是要表示的对象。

第二个是以对象 id() 为键的字典，这些对象是当前表示上下文的一部分（影响 object 表示的直接和间接容器）；如果需要呈现一个已经在 context 中表示的对象，则第三个返回值应当为 True。对 format() 方法的递归调用应当将容器的附加条目添加到此字典中。

第三个参数 maxlevels 给出了对递归的请求限制；如果没有请求限制则其值将为 0。此参数应当不加修改地传给递归调用。

第四个参数 level 给出于当前层级；传给递归调用的参数值应当小于当前调用的值。

hd51cc

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
标准库：pprint --- 数据美化输出

Lib/pprint.pypprint模块提供了“美化打印”任意 Python 数据结构的功能，这种美化形式可用作对解释器的输入。如果经格式化的结构包含非基本 Python 类型的对象，则其美化形式可能无法被加载。包含文件、套接字或类对象，以及许多其他不能用 Python 字面值来表示的对象都有可能导致这样的结果。pprint模块定义了一个类：class pprint.PrettyPrinter(indent=1, width=80, depth=None, stream=None,...
复制链接

扫一扫

专栏目录