11. 标准库概览 – Part II¶

第二个课程包括支持专业编程需求的更高级模块。这些模块很少出现在小脚本中。

11.1. 输出格式化¶

reprlib 模块提供了一个用来缩写显示大型或深层嵌套容器的定制版repr() 。

>>> import reprlib
>>> reprlib.repr(set('supercalifragilisticexpialidocious'))
"{'a', 'c', 'd', 'e', 'f', 'g', ...}"

pprint模块为打印对解释器可读的内置和用户自定义的对象提供了更复杂控制方式.当结果长于一行时，“漂亮的打印机”添加换行符和缩进以更清楚地显示数据结构：

>>> import pprint
>>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',
...     'yellow'], 'blue']]]
...
>>> pprint.pprint(t, width=30)
[[[['black', 'cyan'],
   'white',
   ['green', 'red']],
  [['magenta', 'yellow'],
   'blue']]]

textwrap模块使文本内容的段落格式适应给定的屏幕宽度:

>>> 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 模块访问一种特定格式的数据库.local 模块的format函数的grouping[分组]属性直接提供一种用组分隔符格式化数字的方式:

>>> 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. 模板化 ¶

string 模板包含一个拥有简化语法适用于客户端用户编辑的通用的 Template 类.这允许用户自定义他们的应用程序，而不必更改应用程序。

格式是使用由 $ 与有效的 Python 标识符（字母数字字符和下划线）命名的占位符.占位符周围的大括号允许它使用更多的字母数字字符并且中间没有空格。写 $$ 创建一个单一的转义的 $ :

>>> 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()方法可能更合适, 因为用户提供的数据可能不完整,而safe_substitute方法将不会处理数据丢失了的占位符.

>>> 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.'

模板子类可以指定自定义分隔符。例如，照片浏览器的批量重命名实用程序可以选择对占位符使用百分号，例如当前日期，图像序列号或文件格式：

>>> 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 Web报告替换自定义模板。

11.3. 使用二进制文件记录数据布局¶

struct 模块提供了 pack() 和 unpack() 方法来处理可变长度的二进制记录格式。下面的示例演示如何遍历一个 ZIP 文件的标头信息而无需使用 zipfile 模块。包代码"H" 和 "I"分别表示2个字节和4个字节的无符号数字。"<"

import struct

with open('myfile.zip', 'rb') as f:
    data = f.read()

start = 0
for i in range(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. 多线程¶

线程是用于解耦不依赖于从属的任务的技术。线程可用于提高接受用户输入的应用程序的响应性，而其他任务则在后台运行。相关用例是在另一个线程中与计算并行运行I / O。

下面的代码演示了当主程序在运行的同时，高层的 threading 模块可以在后台执行任务。

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.')

多线程应用程序的主要挑战是协调共享数据或其他资源的线程。为此，线程模块提供多个同步原语，包括锁，事件，条件变量和信号量。

虽然这些工具是强大的，小的设计错误可能导致难以重现的问题。因此，任务协调的首选方法是将所有对某个资源的访问集中在单个线程中，然后使用queue模块向该线程提供来自其他线程的请求。使用队列对象进行线程间通信和协调的应用程序更易于设计，更易于阅读和更可靠。

11.5. Logging¶

logging模块提供了一个全功能和灵活的日志系统。最简单的，日志消息发送到文件或sys.stderr：

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')

这将产生以下输出：

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. 弱引用¶

Python执行自动内存管理（大多数对象采用引用计数和垃圾回收以消除循环）。在最后一次对它的引用被消除后，内存被释放。

这种方法适用于大多数应用程序，但有时只需要跟踪对象，只要它们被其他东西使用。不幸的是，只是跟踪它们会创建一个引用，这个引用会一直存在。weakref模块提供了用于跟踪对象的工具，而无需创建引用。当不再需要该对象时，它会自动从weakref表中删除，并触发weakref对象的回调。典型的应用包括缓存创建昂贵的对象：

>>> 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:/python35/lib/weakref.py", line 46, in __getitem__
    o = self.data[key]()
KeyError: 'primary'

11.7. 使用列表的工具¶

许多数据结构需求可以通过内建列表类型满足。然而，有时需要具有不同性能权衡的替代实现。

array 模块提供了 array()对象，这个对象像列表一样，它只存储相似的数据并且更加简洁。以下示例显示存储为两个字节无符号二进制数（类型代码“H”）的数字数组，而不是每个条目通常是16个字节的Python int对象的常规列表：

>>> from array import array
>>> a = array('H', [4000, 10, 700, 22222])
>>> sum(a)
26932
>>> a[1:3]
array('H', [10, 700])

collections 模块提供了一个 deque()对象，像list但是拥有从左边更快的赋值速度和读取速度，但是从中间检索会更慢。这些对象非常适合实现队列和广度第一树搜索：

>>> from collections import deque
>>> d = deque(["task1", "task2", "task3"])
>>> d.append("task4")
>>> print("Handling", d.popleft())
Handling task1

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 模块：

>>> 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模块提供了基于常规列表实现堆的功能。最低值条目始终保持在位置零。这对于重复访问最小元素但不想运行完整列表排序的应用程序很有用：

>>> 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模块提供了用于十进制浮点运算的Decimal数据类型。与内置的float二进制浮点的实现相比，该类特别有用

金融应用和其他需要精确十进制表示的用途，
控制精度，
跟踪重要的小数位，或
应用程序，其中用户期望结果匹配手工进行的计算。

例如，计算70％手机费用的5％税在十进制浮点和二进制浮点中给出不同的结果。如果结果四舍五入到最接近的分数，差异变得显着：

>>> from decimal import *
>>> round(Decimal('0.70') * Decimal('1.05'), 2)
Decimal('0.74')
>>> round(.70 * 1.05, 2)
0.73

Decimal结果保留结尾的零，从具有两个有效数字的乘数自动推断四个有效数字。小数通过手工再现数学，并避免了当二进制浮点不能精确表示十进制数时可能出现的问题。

精确的呈现结果使得 Decimal 类在执行二进制浮点数的取模运算和相等测试时不适合：

>>> 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模块提供具有所需精度的算术操作：

>>> getcontext().prec = 36
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857')