当Python中列表不是首选时，我们还可以用什么？

当Python中列表不是首选时，我们还可以用什么？

---

更多文章代码详情:

可以查看博主GitHub地址：https://github.com/TheAlgorithm-SimpleChinese/Python

博主个人网站：https://www.iwtmbtly.com/

---

虽然列表既灵活又简单，但面对各类需求时，我们可能会有更好的选择。比如，要存放 1000 万个浮点数的话，数组（array）的效率要高得多，因为数组在背后存的并不是 float 对象，而是数字的机器翻译，也就是字节表述。这一点就跟 C 语言中的数组一 样。再比如说，如果需要频繁对序列做先进先出的操作，deque（双端队列）的速度应该 会更快。

如果在你的代码里，包含操作（比如检查一个元素是否出现在一个集合中）的 频率很高，用 set（集合）会更合适。set 专为检查元素是否存在做过优化。但是它 并不是序列，因为 set 是无序的。

数组

如果我们需要一个只包含数字的列表，那么 array.array 比 list 更高效。数组支持所 有跟可变序列有关的操作，包括 .pop、.insert 和 .extend。另外，数组还提供从文件 读取和存入文件的更快的方法，如 .frombytes 和 .tofile。

Python 数组跟 C 语言数组一样精简。创建数组需要一个类型码，这个类型码用来表示在 底层的 C 语言应该存放怎样的数据类型。比如 b 类型码代表的是有符号的字符（signed char），因此 array(‘b’) 创建出的数组就只能存放一个字节大小的整数，范围从 -128 到 127，这样在序列很大的时候，我们能节省很多空间。而且 Python 不会允许你在数组里 存放除指定类型之外的数据。

下例展示了从创建一个有 1000 万个随机浮点数的数组开始，到如何把这个数组存放 到文件里，再到如何从文件读取这个数组。

>>> from array import array # 引入 array 类型。
>>> from random import random
# 利用一个可迭代对象来建立一个双精度浮点数组（类型码是 'd'），这里我们用的可迭代对象是一个生成器表达式。
>>> floats = array('d', (random() for i in range(10**7)))
>>> floats[-1] # 查看数组的最后一个元素。
0.07802343889111107
>>> 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()
>>> floats2[-1] # 查看新数组的最后一个元素。
0.07802343889111107
>>> floats2 == floats # 检查两个数组的内容是不是完全一样。
True

从上面的代码我们能得出结论，array.tofile 和 array.fromfile 用起来很简单。把 这段代码跑一跑，你还会发现它的速度也很快。一个小试验告诉我，用 array.fromfile 从一个二进制文件里读出 1000 万个双精度浮点数只需要 0.1 秒，这比从文本文件里读取 的速度要快 60 倍，因为后者会使用内置的 float 方法把每一行文字转换成浮点数。另 外，使用 array.tofile 写入到二进制文件，比以每行一个浮点数的方式把所有数字写 入到文本文件要快 7 倍。另外，1000 万个这样的数在二进制文件里只占用 80 000 000 个 字节（每个浮点数占用 8 个字节，不需要任何额外空间），如果是文本文件的话，我们需 要 181 515 739 个字节。

下表对数组和列表的功能做了一些总结：

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

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

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

如果你总是跟数组打交道，却没有听过 memoryview，那就太遗憾了。下面就来谈谈 memoryview。

内存视图

memoryview 是一个内置类，它能让用户在不复制内容的情况下操作同一个数组的不同切 片。

memoryview 的概念受到了 NumPy 的启发（参见 2.9.3 节）。Travis Oliphant 是 NumPy 的主要作者，他在回答“ When should a memoryview be used?”（http://stackoverflow.com/questions/4845418/when-should-a-memoryview-be-used/）这 个问题时是这样说的：

内存视图其实是泛化和去数学化的 NumPy 数组。它让你在不需要复制内容的前提 下，在数据结构之间共享内存。其中数据结构可以是任何形式，比如 PIL图片、 SQLite 数据库和 NumPy 的数组，等等。这个功能在处理大型数据集合的时候非常重要。

memoryview.cast 的概念跟数组模块类似，能用不同的方式读写同一块内存数据，而且 内容字节不会随意移动。这听上去又跟 C 语言中类型转换的概念差不 多。memoryview.cast 会把同一块内存里的内容打包成一个全新的 memoryview 对象给你。

下面我们利用 memoryview 精准地修改了一个数组的某个字节，这个数组的 元素是 16 位二进制整数：

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

另外，如果利用数组来做高级的数字处理是你的日常工作，那么 NumPy 和 SciPy 应该是 你的常用武器。下面就是对这两个库的简单介绍。

NumPy和SciPy

凭借着 NumPy 和 SciPy 提供的高阶数组和矩阵操作，Python 成为科学计算应用的主流语 言。NumPy 实现了多维同质数组（homogeneous array）和矩阵，这些数据结构不但能处理 数字，还能存放其他由用户定义的记录。通过 NumPy，用户能对这些数据结构里的元素 进行高效的操作。

SciPy 是基于 NumPy 的另一个库，它提供了很多跟科学计算有关的算法，专为线性代数、 数值积分和统计学而设计。SciPy 的高效和可靠性归功于其背后的 C 和 Fortran 代码，而 这些跟计算有关的部分都源自于 Netlib 库（http://www.netlib.org）。换句话说，SciPy 把 基于 C 和 Fortran 的工业级数学计算功能用交互式且高度抽象的 Python 包装起来，让科学 家如鱼得水。

如下例为对 numpy.ndarray 的行和列进行基本操作：

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

NumPy 也可以对 numpy.ndarray 中的元素进行抽象的读取、保存和其他操作：

>>> import numpy
>>> floats = numpy.loadtxt('floats-10M-lines.txt') # 从文本文件里读取 1000 万个浮点数。
>>> floats[-3:] # 利用序列切片来读取其中的最后 3 个数。
array([ 3016362.69195522, 535281.10514262, 4566560.44373946])
>>> floats *= .5 # 把数组里的每个数都乘以 0.5，然后再看看最后 3 个数。
>>> floats[-3:]
array([ 1508181.34597761, 267640.55257131, 2283280.22186973])
>>> from time import perf_counter as pc # 导入精度和性能都比较高的计时器
>>> t0 = pc(); floats /= 3; pc() - t0 # 把每个元素都除以 3，可以看到处理 1000 万个浮点数所需的时间还不足 40 毫秒。
0.03690556302899495
>>> numpy.save('floats-10M', floats) # 把数组存入后缀为 .npy 的二进制文件。
# 将上面的数据导入到另外一个数组里，这次 load 方法利用了一种叫作内存映射的机
# 制，它让我们在内存不足的情况下仍然可以对数组做切片。
>>> floats2 = numpy.load('floats-10M.npy', 'r+') 
>>> floats2 *= 6
>>> floats2[-3:] # 把数组里每个数乘以 6 之后，再检视一下数组的最后 3 个数。
memmap([3016362.69195522, 535281.10514262, 4566560.44373946])

以上的内容仅仅是九牛一毛。NumPy 和 SciPy 都是异常强大的库，也是其他一些很有用的 工具的基石。Pandas（http://pandas.pydata.org）和 Blaze（http://blaze.pydata.org）数据分析 库就以它们为基础，提供了高效的且能存储非数值类数据的数组类型，和读写常见数据文 件格式（例如 csv、xls、SQL转储和 HDF5）的功能。因此，要详细介绍 NumPy 和 SciPy 的话，不写成几本书是不可能的。虽然本书不在此列，但是如果要对 Python 的序列类型 做一个概览，恐怕没有人能忽略 NumPy。

在介绍完扁平序列（包括标准数组和 NumPy 数组）之后，让我们把目光投向 Python 中可 以取代列表的另外一种数据结构：队列。

双向队列和其他形式的队列

利用 .append 和 .pop 方法，我们可以把列表当作栈或者队列来用（比如，把 .append 和 .pop(0) 合起来用，就能模拟栈的“先进先出”的特点）。但是删除列表的第一个元素 （抑或是在第一个元素之前添加一个元素）之类的操作是很耗时的，因为这些操作会牵扯到移动列表里的所有元素。

collections.deque 类（双向队列）是一个线程安全、可以快速从两端添加或者删除元 素的数据类型。而且如果想要有一种数据类型来存放“最近用到的几个元素”，deque 也是 一个很好的选择。这是因为在新建一个双向队列的时候，你可以指定这个队列的大小，如 果这个队列满员了，还可以从反向端删除过期的元素，然后在尾端添加新的元素。

下例中有几个双向队列的典型操作：

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

双向队列实现了大部分列表所拥有的方法，也有一些额外的符合自身设计的方法，比如说 popleft 和 rotate。但是为了实现这些方法，双向队列也付出了一些代价，从队列中间 删除元素的操作会慢一些，因为它只对在头尾的操作进行了优化。

append 和 popleft 都是原子操作，也就说是 deque 可以在多线程程序中安全地当作先进先出的栈使用，而使用者不需要担心资源锁的问题。

下表为列表和双向队列的方法：

除了 deque 之外，还有些其他的 Python 标准库也有对队列的实现。

queue

提供了同步（线程安全）类 Queue、LifoQueue 和 PriorityQueue，不同的线程可 以利用这些数据类型来交换信息。这三个类的构造方法都有一个可选参数 maxsize，它 接收正整数作为输入值，用来限定队列的大小。但是在满员的时候，这些类不会扔掉旧的 元素来腾出位置。相反，如果队列满了，它就会被锁住，直到另外的线程移除了某个元素 而腾出了位置。这一特性让这些类很适合用来控制活跃线程的数量。

multiprocessing

这个包实现了自己的 Queue，它跟 queue.Queue 类似，是设计给进程间通信用的。 同时还有一个专门的 multiprocessing.JoinableQueue 类型，可以让任务管理变得更 方便。

asyncio

Python 3.4 新提供的包，里面有 Queue、LifoQueue、PriorityQueue 和 JoinableQueue，这些类受到 queue 和 multiprocessing 模块的影响，但是为异步编 程里的任务管理提供了专门的便利。

heapq

跟上面三个模块不同的是，heapq 没有队列类，而是提供了 heappush 和 heappop 方法，让用户可以把可变序列当作堆队列或者优先队列来使用。