这第二部分将介绍支持专业编程需要的更高级模块，这些模块很少出现在小脚本中。
11.1.输出格式化 (Output Formatting)
reprlib 模块提供了 repr() 的一个版本，该版本用于定制大型或深层嵌套容器的缩略显示：
1
2
3
>>> import reprlib
>>> reprlib.repr(set('supercalifragilisticexpialidocious'))
"{'a', 'c', 'd', 'e', 'f', 'g', ...}"
pprint 模块以解释器可读的方式对内置和用户定义的对象提供了更复杂的打印控制。当结果超过一行时，“优雅的打印机 (pretty printer)” 会添加换行和缩进，以便更清楚地显示数据结构
1
2
3
4
5
6
7
8
9
10
>>> import pprint
>>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',
... 'yellow'], 'blue']]]
...
>>> pprint.pprint(t, width=30)
[[[['black', 'cyan'],
'white',
['green', 'red']],
[['magenta', 'yellow'],
'blue']]]
模块格式化文本段落以适应给定的屏幕宽度：
1
2
3
4
5
6
7
8
9
10
>>> import textwrap
>>> doc = """The wrap() method is just like fill() except that it returns
... a list of strings instead of one big string with newlines to separate
... the wrapped lines."""
...
>>> print(textwrap.fill(doc, width=40))
The wrap() method is just like fill()
except that it returns a list of strings
instead of one big string with newlines
to separate the wrapped lines.
locale 模块访问特定区域性数据格式的数据库。locale 的format函数的分组属性提供了使用组分隔符对数字进行格式化的直接方法：
1
2
3
4
5
6
7
8
9
10
>>> import locale
>>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')
'English_United States.1252'
>>> conv = locale.localeconv() # get a mapping of conventions
>>> x = 1234567.8
>>> locale.format("%d", x, grouping=True)
'1,234,567'
>>> locale.format_string("%s%.*f", (conv['currency_symbol'],
... conv['frac_digits'], x), grouping=True)
'$1,234,567.80'
11.2.模板 (Templating)
string 模块包含一个通用的 Template 类，其语法经过简化，适合终端用户进行编辑。这允许用户在不更改应用程序的情况下自定义其应用程序。
该格式使用由$ 和有效的Python标识符 (字母数字字符和下划线) 组成的占位符名称。用大括号将占位符括起来，允许它后面跟着更多的字母数字字符，其间没有空格。写 $$ 将转义成一个 $ (即实际打印一个 $) ：
1
2
3
4
>>> from string import Template
>>> t = Template('${village}folk send $$10 to $cause.')
>>> t.substitute(village='Nottingham', cause='the ditch fund')
'Nottinghamfolk send $10 to the ditch fund.'
当字典或关键字参数不支持占位符时，substitute() 方法会抛出一个 KeyError 。对于邮件合并风格的应用程序，用户提供的数据可能不完整，那么使用 safe_substitute() 方法可能更合适，如果在数据丢失，该方法将保持占位符不变 (看下面代码域中最后一行中的 $owner)：
1
2
3
4
5
6
7
8
>>> t = Template('Return the $item to $owner.')
>>> d = dict(item='unladen swallow')
>>> t.substitute(d)
Traceback (most recent call last):
...
KeyError: 'owner'
>>> t.safe_substitute(d)
'Return the unladen swallow to $owner.'
Template 子类可以指定一个自定义的分隔符。例如，照片浏览器的批量重命名实用程序可能会选择对占位符 (比如当前日期、图片序号或文件格式) 使用百分号 % ：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> import time, os.path
>>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']
>>> class BatchRename(Template):
... delimiter = '%'
>>> fmt = input('Enter rename style (%d-date %n-seqnum %f-format): ')
Enter rename style (%d-date %n-seqnum %f-format): Ashley_%n%f
>>> t = BatchRename(fmt)
>>> date = time.strftime('%d%b%y')
>>> for i, filename in enumerate(photofiles):
... base, ext = os.path.splitext(filename)
... newname = t.substitute(d=date, n=i, f=ext)
... print('{0} --> {1}'.format(filename, newname))
img_1074.jpg --> Ashley_0.jpg
img_1076.jpg --> Ashley_1.jpg
img_1077.jpg --> Ashley_2.jpg
模板化的另一个应用是将程序逻辑和多种输出格式的细节分离开来，这使得使用定制模板代替 XML 文件、纯文本报告和 HTML 网页报告成为可能。
11.3.使用二进制数据记录布局 (Working with Binary Data Record Layouts)
struct 模块提供 pack() 和 unpack()函数，用于处理可变长度的二进制记录格式。下面的例子展示了如何在不使用 zipfile 模块的情况下循环遍历 ZIP 文件的头信息。封装码 "H" 和 "I" 分别代表两个和四个字节的无符号数字，< 表示它们是标准大小并且按小端字节顺序排序：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import struct
with open('myfile.zip', 'rb') as f:
data = f.read()
start = 0
for i in range(3): # 显示前3个文件的文件头 show the first 3 file headers
start += 14
fields = struct.unpack('<IIIHH', data[start:start+16])
crc32, comp_size, uncomp_size, filenamesize, extra_size = fields
start += 16
filename = data[start:start+filenamesize]
start += filenamesize
extra = data[start:start+extra_size]
print(filename, hex(crc32), comp_size, uncomp_size)
start += extra_size + comp_size # 跳到下一个文件头 skip to the next header
11.4.多线程 (Multi-threading)
线程是一种解耦不按顺序相关任务的技术。当其他任务在后台运行时，线程可用于提高接受用户输入的应用程序的响应能力。一个相关的用例是在另一个线程中并行地运行输入/输出 (I/O)。
下面的代码显示了在主程序继续运行过程中，高级 threading 模块如何在后台运行任务：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import threading, zipfile
class AsyncZip(threading.Thread):
def __init__(self, infile, outfile):
threading.Thread.__init__(self)
self.infile = infile
self.outfile = outfile
def run(self):
f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)
f.write(self.infile)
f.close()
print('Finished background zip of:', self.infile)
background = AsyncZip('mydata.txt', 'myarchive.zip')
background.start()
print('The main program continues to run in foreground.')
background.join() # Wait for the background task to finish
print('Main program waited until background was done.')
多线程应用程序的主要挑战是协调共享数据或其他资源的线程。为此，线程模块提供了许多同步原语 (synchronization primitives)，包括锁、事件、条件变量和信号量。
尽管这些工具功能强大，但微小的设计错误可能会导致难以重现的问题。因此，任务协调的首选方法是将对资源的所有访问集中在一个线程中，然后使用 queue 模块将来自其他线程的请求提供给该线程。使用 队列 (Queue) 对象进行线程间通信和协调的应用程序更容易设计，可读性更强，更可靠。
11.5.日记 (Logging)
logging 模块提供了一个功能齐全、灵活的日志系统。简单来说，日志消息被发送到一个文件或 sys.stderr：
1
2
3
4
5
6
import logging
logging.debug('Debugging information')
logging.info('Informational message')
logging.warning('Warning:config file %s not found', 'server.conf')
logging.error('Error occurred')
logging.critical('Critical error -- shutting down')
这将产生如下输出：
1
2
3
WARNING:root:Warning:config file server.conf not found
ERROR:root:Error occurred
CRITICAL:root:Critical error -- shutting down
默认情况下，信息和调试消息被抑制，输出被发送到标准错误。其他输出选项包括通过电子邮件、数据报、套接字或HTTP服务器的路由消息。新的过滤器可以根据消息优先级选择不同的路由：DEBUG、INFO、WARNING、ERROR和CRITICAL。
可以直接从Python中配置日志系统，也可以从用户可编辑的配置文件中加载日志，以便在不更改应用程序的情况下进行自定义。
11.6.弱引用 (Weak References)
Python执行自动内存管理 (大多数对象的引用计数和 垃圾收集 (garbage collection) 以消除循环)。在最后一个对它的引用被消除后不久，内存被释放。
这种方法适用于大多数应用程序，但是，有时只要对象被其他对象使用，就需要跟踪对象。不幸的是，仅仅跟踪它们就会创建一个引用并使得对象永远存在。weakref 模块提供了跟踪对象而不创建引用的工具。当对象不再需要时，它会自动从 weakref 表中删除，weakref 对象会触发回调。典型的应用程序包括缓存创建起来很昂贵的对象：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
>>> import weakref, gc
>>> class A:
... def __init__(self, value):
... self.value = value
... def __repr__(self):
... return str(self.value)
...
>>> a = A(10) # create a reference
>>> d = weakref.WeakValueDictionary()
>>> d['primary'] = a # does not create a reference
>>> d['primary'] # fetch the object if it is still alive
10
>>> del a # remove the one reference
>>> gc.collect() # run garbage collection right away
0
>>> d['primary'] # entry was automatically removed
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
d['primary'] # entry was automatically removed
File "C:/python38/lib/weakref.py", line 46, in __getitem__
o = self.data[key]()
KeyError: 'primary'
11.7.列表工具 (Tools for Working with Lists)
内置的列表类型可以满足许多数据结构需求。然而，有时需要权衡不同性能而采用替代实现。
Many data structure needs can be met with the built-in list type. However, sometimes there is a need for alternative implementations with different performance trade-offs.
array 模块提供了一个 array() 对象，它类似于列表，但是只存储同类数据并且存储得更紧凑。下面的示例显示了一个以双字节无符号二进制数 (类型码为 “H”) 形式存储的数字数组，而不是Python常规列表中每个条目通常为16字节的 int 对象。
1
2
3
4
5
6
>>> from array import array
>>> a = array('H', [4000, 10, 700, 22222])
>>> sum(a)
26932
>>> a[1:3]
array('H', [10, 700])
collections 模块提供了一个 deque() 对象，它类似于一个列表，但是左边的追加和弹出速度更快，而中间的查找速度更慢。这些对象非常适合实现队列和广度优先树搜索：
1
2
3
4
5
>>> from collections import deque
>>> d = deque(["task1", "task2", "task3"])
>>> d.append("task4")
>>> print("Handling", d.popleft())
Handling task1
1
2
3
4
5
6
7
unsearched = deque([starting_node])
def breadth_first_search(unsearched):
node = unsearched.popleft()
for m in gen_moves(node):
if is_goal(m):
return m
unsearched.append(m)
除了可选的列表实现之外，这个库还提供了其他工具，比如 bisect 模块，它具有处理排序列表的函数：
1
2
3
4
5
>>> import bisect
>>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]
>>> bisect.insort(scores, (300, 'ruby'))
>>> scores
[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]
heapq 模块提供了基于常规列表实现堆的功能。最小值总是保持在位置0 (但是不保证升序排序，译者注)。这对于重复访问最小元素但不希望运行完整列表排序的应用程序非常有用：
1
2
3
4
5
6
>>> from heapq import heapify, heappop, heappush
>>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
>>> heapify(data) # 以堆顺序重排列表 rearrange the list into heap order
>>> heappush(data, -5) # 增加一个条目 add a new entry
>>> [heappop(data) for i in range(3)] # 提取最小的三个条目 fetch the three smallest entries
[-5, 0, 1] # 每弹出一个都重排一次
11.8.十进制浮点数计算 (Decimal Floating Point Arithmetic)
decimal 模块为十进制浮点运算提供了十进制 (Decimal) 数据类型。与二进制浮点数的内置 float 实现相比，该类对于下面绩点很有用：
- 需要精确的十进制表示的金融应用和其他用途；
控制精度；
- 控制舍入以满足法律或法规要求；
- 有效小数位的跟踪，或
- 用户期望结果与手工计算结果匹配的应用程序。
例如，计算对70美分的电话费征收5%的税，使用十进制浮点数和二进制浮点数会得到不同的结果。如果将结果四舍五入到最接近的美分上，这种差异将变得非常显著：
1
2
3
4
5
>>> from decimal import *
>>> round(Decimal('0.70') * Decimal('1.05'), 2)
Decimal('0.74')
>>> round(.70 * 1.05, 2)
0.73
十进制 (Decimal`) 结果保留一个尾随的零，自动从具有两位有效值的乘法中推断四位有效值 (automatically inferring four place significance from multiplicands with two place significance)。十进制可以再现手工方式进行的数学运算，避免了二进制浮点数不能准确表示十进制数时可能出现的问题。
精确表示使Decimal 类能够执行不适合二进制浮点数的模运算和相等性测试：
1
2
3
4
5
6
7
8
9
>>> Decimal('1.00') % Decimal('.10')
Decimal('0.00')
>>> 1.00 % 0.10
0.09999999999999995
>>> sum([Decimal('0.1')]*10) == Decimal('1.0')
True
>>> sum([0.1]*10) == 1.0
False
decimal 模块提供了所需的算术精度：
1
2
3
>>> getcontext().prec = 36
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857')