《流畅的python》 2.9 当列表不是首选时 读书笔记

虽然列表既灵活又简单，但面对各类需求时，我们可能会有更好的选择。比如，要存放 1000 万个浮点数的话，数组（array）的效率要高得多，因为数组在背后存的并不是 float 对象，而是数字的机器翻译，也就是字节表述。
如果需要频繁对序列做先进先出的操作，deque（双端队列）的速度应该会更快。
如果在你的代码里，包含操作（比如检查一个元素是否出现在一个集合中）的 频率很高，用 set（集合）会更合适。set 专为检查元素是否存在做过优化。但是它 并不是序列，因为 set 是无序的。
一、数组
如果我们需要一个只包含数字的列表，那么 array.array 比 list 更高效。数组支持所 有跟可变序列有关的操作，包括 .pop、.insert 和 .extend。另外，数组还提供从文件 读取和存入文件的更快的方法，如 .frombytes 和 .tofile。
例子：从创建一个有 1000 万个随机浮点数的数组开始，到如何把这个数组存放 到文件里，再到如何从文件读取这个数组。

from array import array  # 引入 array 类型。
from random import random
floats = array('d', (random() for i in range(10 ** 7)))  # 利用一个可迭代对象来建立一个双精度浮点数组（类型码是 'd'），这里我们用的可迭代对象是一个生成器表达式。
print(floats[-1])  # 查看数组的最后一个元素。
fp = open('floats.bin', 'wb')
floats.tofile(fp)  # 把数组存入一个二进制文件里。
fp.close()
floats2 = array('d')  # 新建一个双精度浮点空数组。
fp = open('floats.bin', 'rb')
floats2.fromfile(fp, 10**7)  # 把1000万个浮点数从二进制文件里读取出来。
fp.close()
print(floats2[-1])  # 查看新数组的最后一个元素。
if floats2 == floats:  # 检查两个数组的内容是不是完全一样。
    print(True)
else:
    print(False)

从上面的代码我们能得出结论，array.tofile 和 array.fromfile 用起来很简单。
把 这段代码跑一跑，你还会发现它的速度也很快。一个小试验告诉我，用 array.fromfile 从一个二进制文件里读出 1000 万个双精度浮点数只需要 0.1 秒，这比从文本文件里读取 的速度要快 60 倍，因为后者会使用内置的 float 方法把每一行文字转换成浮点数。另 外，使用 array.tofile 写入到二进制文件，比以每行一个浮点数的方式把所有数字写 入到文本文件要快 7 倍。另外，1000 万个这样的数在二进制文件里只占用 80 000 000 个 字节（每个浮点数占用 8 个字节，不需要任何额外空间，如果是文本文件的话，我们需 要 181 515 739 个字节。
另外一个快速序列化数字类型的方法是使用 pickle模块。pickle.dump 处理浮点 数组的速度几乎跟 array.tofile 一样快。不过前者可以处理几乎所有的内置数字 类型，包含复数、嵌套集合，甚至用户自定义的类。

列表

数组

s.__add(s2)__

•

•

s + s2，拼接

s.__iadd(s2)__

•

•

s += s2，就地拼接

s.append(e)

•

•

在尾部添加一个元素

s.byteswap

•

翻转数组内每个元素的字节序列，转换字节序

s.clear()

•

删除所有元素

s.__contains__(e)

•

•

s 是否含有 e

s.copy()

•

对列表浅复制

s.__copy__()

•

对 copy.copy 的支持

s.count(e)

•

•

s 中 e 出现的次数

s.__deepcopy__()

•

对 copy.deepcopy 的支持

s.__delitem__(p)

•

•

删除位置 p 的元素

s.extend(it)

•

•

将可迭代对象 it 里的元素添加到尾部

s.frombytes(b)

•

将压缩成机器值的字节序列读出来添加到尾部

s.fromfile(f, n)

•

将二进制文件 f 内含有机器值读出来添加到尾部，最多添加 n 项

s.fromlist(l)

•

将列表里的元素添加到尾部，如果其中任何一个元素导致了 TypeError 异 常，那么所有的添加都会取消

s.__getitem__(p)

•

•

s[p]，读取位置 p 的元素

s.index(e)

•

•

找到 e 在序列中第一次出现的位置

s.insert(p, e)

•

•

在位于 p 的元素之前插入元素 e

s.itemsize

•

数组中每个元素的长度是几个字节

s.__iter__()

•

•

返回迭代器

s.__len__()

•

•

len(s)，序列的长度

s.__mul__(n)

•

•

s * n，重复拼接

s.__imul__(n)

•

•

s *= n，就地重复拼接

s.__rmul__(n)

•

•

n * s，反向重复拼接*

s.pop([p])

•

•

删除位于 p 的值并返回这个值，p 的默认值是最后一个元素的位置

s.remove(e)

•

•

删除序列里第一次出现的 e 元素

s.reverse()

•

•

就地调转序列中元素的位置

s.__reversed__()

•

返回一个从尾部开始扫描元素的迭代器

s.__setitem__(p, e)

•

•

s[p] = e，把位于 p 位置的元素替换成 e

s.sort([key], [revers])

•

就地排序序列，可选参数有 key 和 reverse

s.tobytes()

•

把所有元素的机器值用 bytes 对象的形式返回

s.tofile(f)

•

把所有元素以机器值的形式写入一个文件

s.tolist()

•

把数组转换成列表，列表里的元素类型是数字对象

s.typecode

•

返回只有一个字符的字符串，代表数组元素在 C 语言中的类型

从 Python 3.4 开始，数组类型不再支持诸如 list.sort() 这种就地排序方法。要给 数组排序的话，得用 sorted 函数新建一个数组：

a = array.array(a.typecode, sorted(a))

想要在不打乱次序的情况下为数组添加新的元素，bisect.insort 还是能派上用场

二、内存视图
memoryview 是一个内置类，它能让用户在不复制内容的情况下操作同一个数组的不同切 片。
内存视图其实是泛化和去数学化的 NumPy 数组。它让你在不需要复制内容的前提 下，在数据结构之间共享内存。其中数据结构可以是任何形式，比如 PIL图片、 SQLite 数据库和 NumPy 的数组，等等。这个功能在处理大型数据集合的时候非常重 要。
memoryview.cast 的概念跟数组模块类似，能用不同的方式读写同一块内存数据，而且 内容字节不会随意移动。这听上去又跟 C 语言中类型转换的概念差不 多。memoryview.cast 会把同一块内存里的内容打包成一个全新的 memoryview 对象给 你。
通过改变数组中的一个字节来更新数组里某个元素的值：

numbers = array('h', [-2, -1, 0, 1, 2])  # 利用含有 5 个短整型有符号整数的数组（类型码是 'h'）创建一个 memoryview
memv = memoryview(numbers)
print(len(memv))
print(memv[0])  # memv 里的 5 个元素跟数组里的没有区别。
memv_oct = memv.cast('B')  # 创建一个 memv_oct，这一次是把 memv 里的内容转换成 'B' 类型，也就是无符号字 符。
print(memv_oct.tolist())  # 以列表的形式查看 memv_oct 的内容。
memv_oct[5] = 4  # 把位于位置 5 的字节赋值成 4。
print(numbers)  # 因为我们把占 2 个字节的整数的高位字节改成了 4，所以这个有符号整数的值就变成 了 1024。

运行结果：

5
-2
[254, 255, 255, 255, 0, 0, 1, 0, 2, 0]
array('h', [-2, -1, 1024, 1, 2])

三、 NumPy和SciPy
NumPy 实现了多维同质数组（homogeneous array）和矩阵，这些数据结构不但能处理 数字，还能存放其他由用户定义的记录。通过 NumPy，用户能对这些数据结构里的元素 进行高效的操作。
SciPy 是基于 NumPy 的另一个库，它提供了很多跟科学计算有关的算法，专为线性代数、 数值积分和统计学而设计。
对 numpy.ndarray 的行和列进行基本操作：

import numpy  # 安装 NumPy 之后，导入它（NumPy 并不是 Python 标准库的一部分）
a = numpy.arange(12)  # 新建一个 0~11 的整数的 numpy.ndarry，然后把它打印出来。
print(a)
print(type(a))
print(a.shape)  # 看看数组的维度，它是一个一维的、有 12 个元素的数组。
a.shape = 3, 4  # 把数组变成二维的，然后把它打印出来看看。
print(a)
print(a[2])  # 打印出第 2 行。  ? 应为第三行  
print(a[2, 1])  # 打印第 2 行第 1 列的元素。  ? 应为第三行 
print(a[:, 1])  # 把第 1 列打印出来。  ？ 应为第二列
print(a.transpose())  # 把行和列交换，就得到了一个新数组。

运行结果：

[ 0  1  2  3  4  5  6  7  8  9 10 11]
<class 'numpy.ndarray'>
(12,)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[ 8  9 10 11]
9
[1 5 9]
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

NumPy 也可以对 numpy.ndarray 中的元素进行抽象的读取、保存和其他操作。
四、双向队列和其他形式的队列
利用 .append 和 .pop 方法，我们可以把列表当作栈或者队列来用（比如，把 .append 和 .pop(0) 合起来用，就能模拟栈的“先进先出”的特点）。但是删除列表的第一个元素 （抑或是在第一个元素之前添加一个元素）之类的操作是很耗时的，因为这些操作会牵扯 到移动列表里的所有元素。
collections.deque 类（双向队列）是一个线程安全、可以快速从两端添加或者删除元 素的数据类型。而且如果想要有一种数据类型来存放“最近用到的几个元素”，deque 也是 一个很好的选择。这是因为在新建一个双向队列的时候，你可以指定这个队列的大小，如 果这个队列满员了，还可以从反向端删除过期的元素，然后在尾端添加新的元素。

使用双向队列：

from collections import deque
dq = deque(range(10), maxlen=10)  # maxlen 是一个可选参数，代表这个队列可以容纳的元素的数量，而且一旦设定，这个 属性就不能修改了。
print(dq)
dq.rotate(3)  # 队列的旋转操作接受一个参数 n，当 n > 0 时，队列的最右边的 n 个元素会被移动到 队列的左边。当 n < 0 时，最左边的 n 个元素会被移动到右边。
print(dq)
dq.rotate(-4)
print(dq)
dq.appendleft(-1)  # 当试图对一个已满（len(d) == d.maxlen）的队列做尾部添加操作的时候，它头部 的元素会被删除掉。注意在下一行里，元素 0 被删除了。
print(dq)
dq.extend([11, 22, 33])  # 在尾部添加 3 个元素的操作会挤掉 -1、1 和 2。
print(dq)
dq.extendleft([10, 20, 30, 40])  # extendleft(iter) 方法会把迭代器里的元素逐个添加到双向队列的左边，因此迭代 器里的元素会逆序出现在队列里。
print(dq)

运行结果：

deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)
deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 0], maxlen=10)
deque([-1, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
deque([3, 4, 5, 6, 7, 8, 9, 11, 22, 33], maxlen=10)
deque([40, 30, 20, 10, 3, 4, 5, 6, 7, 8], maxlen=10)

1.双向队列实现了大部分列表所拥有的方法，也有一些额外的符合自身设计的方法，比如说 popleft 和 rotate。但是为了实现这些方法，双向队列也付出了一些代价，从队列中间 删除元素的操作会慢一些，因为它只对在头尾的操作进行了优化。
2.append 和 popleft 都是原子操作，也就说是 deque 可以在多线程程序中安全地当作先 进先出的栈使用，而使用者不需要担心资源锁的问题。
3.queue 提供了同步（线程安全）类 Queue、LifoQueue 和 PriorityQueue，不同的线程可以利用这些数据类型来交换信息。这三个类的构造方法都有一个可选参数 maxsize，它接收正整数作为输入值，用来限定队列的大小。但是在满员的时候，这些类不会扔掉旧的元素来腾出位置。相反，如果队列满了，它就会被锁住，直到另外的线程移除了某个元素而腾出了位置。这一特性让这些类很适合用来控制活跃线程的数量。
4.multiprocessing 这个包实现了自己的 Queue，它跟 queue.Queue 类似，是设计给进程间通信用的。 同时还有一个专门的 multiprocessing.JoinableQueue 类型，可以让任务管理变得更 方便。
5. asyncio Python 3.4 新提供的包，里面有 Queue、LifoQueue、PriorityQueue 和 JoinableQueue，这些类受到 queue 和 multiprocessing 模块的影响，但是为异步编 程里的任务管理提供了专门的便利。
6.heapq 没有队列类，而是提供了 heappush 和 heappop 方法，让用户可以把可变序列当作堆队列或者优先队列来使用。