You are here:  Home » Python » 官方标准库详细简介-第二部分(11)python入门教程(原版)

第二次巡演涵盖了支持专业编程需求的更高级模块。这些模块很少出现在小脚本中。

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模块访问文化特定数据格式的数据库。locale格式函数的分组属性提供了使用组分隔符格式化数字的直接方法:

>>>
>>> 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()方法可能更合适 – 如果数据丢失,它将保持占位符不变:

>>>
>>> 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()使用可变长度二进制记录格式的功能。以下示例说明如何在不使用zipfile模块的情况下循环ZIP文件中的标头信息 。打包代码"H"并分别"I"表示两个和四个字节的无符号数字。在"<"表明他们是标准的尺寸和little-endian字节顺序:

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模块向来自其他线程的请求提供该线程。使用Queue对象进行线程间通信和协调的应用程序更易于设计,更易读,更可靠。

11.5。日志

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

 

11.7。使用列表的工具

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

array模块提供的array()对象类似于仅存储同类数据的列表,并且更紧凑地存储它。以下示例显示存储为两个字节无符号二进制数(typecode "H")的数字数组,而不是通常的Python int对象列表的每个条目通常16个字节:

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

 

collections模块提供的deque()对象类似于列表,具有更快的附加和左侧弹出,但在中间查找较慢。这些对象非常适合实现队列和广度优先树搜索:

>>>
>>> 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结果保留尾随零,自动推断来自两个地方的意义被乘数4点地方的意义。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')