11. 标准库浏览 – Part II¶

第二部分包含了支持专业编程工作所需的更高级的模块，这些模块很少出现在小脚本中。

11.1. 输出格式¶

repr 模块为大型的或深度嵌套的容器缩写显示提供了 repr() 函数的一个定制版本:

  1. >>> import repr
  2. >>> repr.repr(set('supercalifragilisticexpialidocious'))
  3. "set(['a', 'c', 'd', 'e', 'f', 'g', ...])"

pprint 模块给老手提供了一种解释器可读的方式深入控制内置和用户自定义对象的打印。当输出超过一行的时候，“美化打印(pretty printer)”添加断行和标识符，使得数据结构显示的更清晰:

  1. >>> import pprint
  2. >>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',
  3. ...     'yellow'], 'blue']]]
  4. ...
  5. >>> pprint.pprint(t, width=30)
  6. [[[['black', 'cyan'],
  7.    'white',
  8.    ['green', 'red']],
  9.   [['magenta', 'yellow'],
  10.    'blue']]]

textwrap 模块格式化文本段落以适应设定的屏宽:

  1. >>> import textwrap
  2. >>> doc = """The wrap() method is just like fill() except that it returns
  3. ... a list of strings instead of one big string with newlines to separate
  4. ... the wrapped lines."""
  5. ...
  6. >>> print textwrap.fill(doc, width=40)
  7. The wrap() method is just like fill()
  8. except that it returns a list of strings
  9. instead of one big string with newlines
  10. to separate the wrapped lines.

locale 模块按访问预定好的国家信息数据库。locale 的格式化函数属性集提供了一个直接方式以分组标示格式化数字:

  1. >>> import locale
  2. >>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')
  3. 'English_United States.1252'
  4. >>> conv = locale.localeconv()          # get a mapping of conventions
  5. >>> x = 1234567.8
  6. >>> locale.format("%d", x, grouping=True)
  7. '1,234,567'
  8. >>> locale.format_string("%s%.*f", (conv['currency_symbol'],
  9. ...                      conv['frac_digits'], x), grouping=True)
  10. '- 1,234,567.80'

11.2. 模板¶

string 提供了一个灵活多变的模版类 Template ，使用它最终用户可以简单地进行编辑。这使用户可以在不进行改变的情况下定制他们的应用程序。

格式使用 - 为开头的 Python 合法标识(数字、字母和下划线)作为占位符。占位符外面的大括号使它可以和其它的字符不加空格混在一起。- - 创建一个单独的 - :

  1. >>> from string import Template
  2. >>> t = Template('- {village}folk send - - 10 to - cause.')
  3. >>> t.substitute(village='Nottingham', cause='the ditch fund')
  4. 'Nottinghamfolk send - 10 to the ditch fund.'

当一个占位符在字典或关键字参数中没有被提供时，substitute() 方法就会抛出一个 KeyError 异常。对于邮件合并风格的应用程序，用户提供的数据可能并不完整，这时使用 safe_substitute() 方法可能更适合。如果数据不完整，它就不会改变占位符:

  1. >>> t = Template('Return the - item to - owner.')
  2. >>> d = dict(item='unladen swallow')
  3. >>> t.substitute(d)
  4. Traceback (most recent call last):
  5.   . . .
  6. KeyError: 'owner'
  7. >>> t.safe_substitute(d)
  8. 'Return the unladen swallow to - owner.'

模板子类可以指定一个自定义分隔符。例如，图像查看器的批量重命名工具可能选择使用百分号作为占位符，像当前日期，图片序列号或文件格式:

  1. >>> import time, os.path
  2. >>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']
  3. >>> class BatchRename(Template):
  4. ...     delimiter = '%'
  5. >>> fmt = input('Enter rename style (%d-date %n-seqnum %f-format):  ')
  6. Enter rename style (%d-date %n-seqnum %f-format):  Ashley_%n%f
  7.  
  8. >>> t = BatchRename(fmt)
  9. >>> date = time.strftime('%d%b%y')
  10. >>> for i, filename in enumerate(photofiles):
  11. ...     base, ext = os.path.splitext(filename)
  12. ...     newname = t.substitute(d=date, n=i, f=ext)
  13. ...     print('{0} --> {1}'.format(filename, newname))
  14.  
  15. img_1074.jpg --> Ashley_0.jpg
  16. img_1076.jpg --> Ashley_1.jpg
  17. img_1077.jpg --> Ashley_2.jpg

模板的另一个应用是把多样的输出格式细节从程序逻辑中分类出来。这便使得 XML 文件，纯文本报表和 HTML WEB 报表定制模板成为可能。

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

struct 模块为使用变长的二进制记录格式提供了 pack() 和 unpack() 函数。下面的示例演示了在不使用 zipfile 模块的情况下如何迭代一个 ZIP 文件的头信息。压缩码 "H" 和 "I" 分别表示2和4字节无符号数字，"<" 表明它们都是标准大小并且按照 little-endian 字节排序:

  1. import struct
  2.  
  3. with open('myfile.zip', 'rb') as f:
  4.     data = f.read()
  5.  
  6. start = 0
  7. for i in range(3):                      # show the first 3 file headers
  8.     start += 14
  9.     fields = struct.unpack('<IIIHH', data[start:start+16])
  10.     crc32, comp_size, uncomp_size, filenamesize, extra_size = fields
  11.  
  12.     start += 16
  13.     filename = data[start:start+filenamesize]
  14.     start += filenamesize
  15.     extra = data[start:start+extra_size]
  16.     print filename, hex(crc32), comp_size, uncomp_size
  17.  
  18.     start += extra_size + comp_size     # skip to the next header

11.4. 多线程¶

线程是一个分离无顺序依赖关系任务的技术。在某些任务运行于后台的时候应用程序会变得迟缓，线程可以提升其速度。一个有关的用途是在 I/O 的同时其它线程可以并行计算。

下面的代码显示了高级模块 threading 如何在主程序运行的同时运行任务:

  1. import threading, zipfile
  2.  
  3. class AsyncZip(threading.Thread):
  4.     def __init__(self, infile, outfile):
  5.         threading.Thread.__init__(self)
  6.         self.infile = infile
  7.         self.outfile = outfile
  8.     def run(self):
  9.         f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)
  10.         f.write(self.infile)
  11.         f.close()
  12.         print 'Finished background zip of:', self.infile
  13.  
  14. background = AsyncZip('mydata.txt', 'myarchive.zip')
  15. background.start()
  16. print 'The main program continues to run in foreground.'
  17.  
  18. background.join()    # Wait for the background task to finish
  19. print 'Main program waited until background was done.'

多线程应用程序的主要挑战是协调线程，诸如线程间共享数据或其它资源。为了达到那个目的，线程模块提供了许多同步化的原生支持，包括：锁，事件，条件变量和信号灯。

尽管这些工具很强大，微小的设计错误也可能造成难以挽回的故障。因此，任务协调的首选方法是把对一个资源的所有访问集中在一个单独的线程中，然后使用 Queue 模块用那个线程服务其他线程的请求。为内部线程通信和协调而使用 Queue.Queue 对象的应用程序更易于设计，更可读，并且更可靠。

11.5. 日志¶

logging 模块提供了完整和灵活的日志系统。它最简单的用法是记录信息并发送到一个文件或 sys.stderr:

  1. import logging
  2. logging.debug('Debugging information')
  3. logging.info('Informational message')
  4. logging.warning('Warning:config file %s not found', 'server.conf')
  5. logging.error('Error occurred')
  6. logging.critical('Critical error -- shutting down')

输出如下:

  1. WARNING:root:Warning:config file server.conf not found
  2. ERROR:root:Error occurred
  3. CRITICAL:root:Critical error -- shutting down

默认情况下捕获信息和调试消息并将输出发送到标准错误流。其它可选的路由信息方式通过 email，数据报文，socket 或者 HTTP Server。基于消息属性，新的过滤器可以选择不同的路由：DEBUG，INFO，WARNING，ERROR 和 CRITICAL 。

日志系统可以直接在 Python 代码中定制，也可以不经过应用程序直接在一个用户可编辑的配置文件中加载。

11.6. 弱引用¶

Python 自动进行内存管理(对大多数的对象进行引用计数和垃圾回收 garbage collection 以循环利用)在最后一个引用消失后，内存会很快释放。

这个工作方式对大多数应用程序工作良好，但是偶尔会需要跟踪对象来做一些事。不幸的是，仅仅为跟踪它们创建引用也会使其长期存在。weakref 模块提供了不用创建引用的跟踪对象工具，一旦对象不再存在，它自动从弱引用表上删除并触发回调。典型的应用包括捕获难以构造的对象:

  1. >>> import weakref, gc
  2. >>> class A:
  3. ...     def __init__(self, value):
  4. ...             self.value = value
  5. ...     def __repr__(self):
  6. ...             return str(self.value)
  7. ...
  8. >>> a = A(10)                   # create a reference
  9. >>> d = weakref.WeakValueDictionary()
  10. >>> d['primary'] = a            # does not create a reference
  11. >>> d['primary']                # fetch the object if it is still alive
  12. 10
  13. >>> del a                       # remove the one reference
  14. >>> gc.collect()                # run garbage collection right away
  15. 0
  16. >>> d['primary']                # entry was automatically removed
  17. Traceback (most recent call last):
  18.   File "<stdin>", line 1, in <module>
  19.     d['primary']                # entry was automatically removed
  20.   File "C:/python33/lib/weakref.py", line 46, in __getitem__
  21.     o = self.data[key]()
  22. KeyError: 'primary'

11.7. 列表工具¶

很多数据结构可能会用到内置列表类型。然而，有时可能需要不同性能代价的实现。

array 模块提供了一个类似列表的 array() 对象，它仅仅是存储数据，更为紧凑。以下的示例演示了一个存储双字节无符号整数的数组(类型编码 "H" )而非存储 16 字节 Python 整数对象的普通正规列表:

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

collections 模块提供了类似列表的 deque() 对象，它从左边添加(append)和弹出(pop)更快，但是在内部查询更慢。这些对象更适用于队列实现和广度优先的树搜索:

  1. >>> from collections import deque
  2. >>> d = deque(["task1", "task2", "task3"])
  3. >>> d.append("task4")
  4. >>> print "Handling", d.popleft()
  5. Handling task1
  6.  
  7. unsearched = deque([starting_node])
  8. def breadth_first_search(unsearched):
  9.     node = unsearched.popleft()
  10.     for m in gen_moves(node):
  11.         if is_goal(m):
  12.             return m
  13.         unsearched.append(m)

除了链表的替代实现，该库还提供了 bisect 这样的模块以操作存储链表:

  1. >>> import bisect
  2. >>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]
  3. >>> bisect.insort(scores, (300, 'ruby'))
  4. >>> scores
  5. [(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]

heapq 提供了基于正规链表的堆实现。最小的值总是保持在 0 点。这在希望循环访问最小元素但是不想执行完整堆排序的时候非常有用:

  1. >>> from heapq import heapify, heappop, heappush
  2. >>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
  3. >>> heapify(data)                      # rearrange the list into heap order
  4. >>> heappush(data, -5)                 # add a new entry
  5. >>> [heappop(data) for i in range(3)]  # fetch the three smallest entries
  6. [-5, 0, 1]

11.8. 十进制浮点数算法¶

decimal 模块提供了一个 Decimal 数据类型用于浮点数计算。相比内置的二进制浮点数实现 float，这个类型有助于：

  • 金融应用和其它需要精确十进制表达的场合，

  • 控制精度，

  • 控制舍入以适应法律或者规定要求，

  • 确保十进制数位精度，

或者

  • 用户希望计算结果与手算相符的场合。

例如，计算 70 分电话费的 5% 税计算，十进制浮点数和二进制浮点数计算结果的差别如下。如果在分值上舍入，这个差别就很重要了:

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

Decimal 的结果总是保有结尾的 0，自动从两位精度延伸到4位。Decimal 重现了手工的数学运算，这就确保了二进制浮点数无法精确保有的数据精度。

高精度使 Decimal 可以执行二进制浮点数无法进行的模运算和等值测试:

  1. >>> Decimal('1.00') % Decimal('.10')
  2. Decimal('0.00')
  3. >>> 1.00 % 0.10
  4. 0.09999999999999995
  5.  
  6. >>> sum([Decimal('0.1')]*10) == Decimal('1.0')
  7. True
  8. >>> sum([0.1]*10) == 1.0
  9. False

decimal 提供了必须的高精度算法:

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

原文:

http://www.pythondoc.com/pythontutorial27/stdlib2.html