流畅的 Python

数据模型

（Data Model）

数据模型其实是对 Python 框架的描述，它规范了这门语言自身构建模块的接口，这些模块包括但不限于序列、迭代器、函数、类和上下文管理器

通过实现特殊方法，自定义数据类型可以表现得跟内置类型一样，从而让我们写出更具表达力的代码——或者说，更具 Python 风格的代码。

特殊方法

Python 解释器碰到特殊的句法时，会使用特殊方法去激活一些基本的对象操作，这些特殊方法的名字以两个下划线开头，以两个下划线结尾（例如 __getitem__）。比如 obj[key] 的背后就是 __getitem__ 方法，为了能求得 my_collection[key] 的值，解释器实际上会调用 my_collection.__getitem__(key)。

魔术方法（magic method）是特殊方法的昵称，也叫双下方法（dunder method）

通过实现特殊方法来利用 Python 数据模型有两个好处：

• 作为你的类的用户，他们不必去记住标准操作的各式名称（“怎么得到元素的总数？是 .size() 还是 .length() 还是别的什么？”）
• 可以更加方便地利用 Python 的标准库，比如 random.choice 函数，从而不用重新发明轮子。

首先明确一点，特殊方法的存在是为了被 Python 解释器调用的，你自己并不需要调用它们。也就是说没有 my_object.__len__() 这种写法，而应该使用 len(my_object)。在执行 len(my_object) 的时候，如果 my_object 是一个自定义类的对象，那么 Python 会自己去调用其中由你实现的 __len__ 方法。

然而如果是 Python 内置的类型，比如列表（list）、字符串（str）、字节序列（bytearray）等，那么 CPython 会抄个近路，__len__ 实际上会直接返回 PyVarObject 里的 ob_size 属性。PyVarObject 是表示内存中长度可变的内置对象的 C 语言结构体。直接读取这个值比调用一个方法要快很多。

很多时候，特殊方法的调用是隐式的，比如 for i in x: 这个语句，背后其实用的是 iter(x)，而这个函数的背后则是 x.__iter__() 方法。当然前提是这个方法在 x 中被实现了。

repr

Python 有一个内置的函数叫 repr，它能把一个对象用字符串的形式表达出来以便辨认，这就是 “字符串表示形式”。

repr 就是通过 __repr__ 这个特殊方法来得到一个对象的字符串表示形式的。如果没有实现 __repr__，当我们在控制台里打印一个向量的实例时，得到的字符串可能会是 <Vector object at 0x10e100070>。

__repr__ 和 __str__ 的区别在于，后者是在 str() 函数被使用，或是在用 print 函数打印一个对象的时候才被调用的，并且它返回的字符串对终端用户更友好。

如果你只想实现这两个特殊方法中的一个，__repr__ 是更好的选择，因为如果一个对象没有 __str__ 函数，而 Python 又需要调用它的时候，解释器会用 __repr__ 作为替代。前者方便我们调试和记录日志，后者则是给终端用户看的。

算术运算符

__add__ 和 __mul__ 这两个方法的返回值都是新创建的向量对象，被操作的两个向量（self 或 other）还是原封不动，代码里只是读取了它们的值而已。

中缀运算符的基本原则就是不改变操作对象，而是产出一个新的值

布尔值

尽管 Python 里有 bool 类型，但实际上任何对象都可以用于需要布尔值的上下文中（比如 if 或 while 语句，或者 and、or 和 not 运算符）。为了判定一个值 x 为真还是为假，Python 会调用 bool(x)，这个函数只能返回 True 或者 False。

默认情况下，我们自己定义的类的实例总被认为是真的，除非这个类对 __bool__ 或者 __len__ 函数有自己的实现。bool(x) 的背后是调用 x.__bool__() 的结果；如果不存在 __bool__ 方法，那么 bool(x) 会尝试调用 x.__len__()。若返回 0，则 bool 会返回 False；否则返回 True。

特殊方法一览

Python 语言参考手册中的“Data Model”（https://docs.python.org/3/reference/datamodel.html）一章列出了 83 个特殊方法的名字，其中 47 个用于实现算术运算、位运算和比较操作。

跟运算符无关的特殊方法

跟运算符相关的特殊方法

其他

• 对序列数据类型的模拟是特殊方法用得最多的地方
• 迭代通常是隐式的，譬如说一个集合类型没有实现 __contains__ 方法，那么 in 运算符就会按顺序做一次迭代搜索。

序列构成的数组

内置序列类型

按元素类型分

Python 标准库用 C 实现了丰富的序列类型，列举如下。

• 容器序列：list、tuple 和 collections.deque 这些序列能存放不同类型的数据。
• 扁平序列：str、bytes、bytearray、memoryview 和 array.array，这类序列只能容纳一种类型。

✅ 容器序列存放的是它们所包含的任意类型的对象的引用，而扁平序列里存放的是值而不是引用。

换句话说，扁平序列其实是一段连续的内存空间。由此可见扁平序列其实更加紧凑，但是它里面只能存放诸如字符、字节和数值这种基础类型。

按能否被修改分

序列类型还能按照能否被修改来分类。

• 可变序列：list、bytearray、array.array、collections.deque 和 memoryview。
• 不可变序列 tuple、str 和 bytes。

下图显示了可变序列（MutableSequence）和不可变序列（Sequence）的差异，同时也能看出前者从后者那里继承了一些方法。这个 UML 类图列举了 collections.abc 中的几个类（超类在左边，箭头从子类指向超类，斜体名称代表抽象类和抽象方法）

元组

除了用作不可变的列表，元组还可以用于没有字段名的记录。鉴于后者常常被忽略，我们先来看看元组作为记录的功用。

元组和记录

元组最大的特征是其不可变性。不可变性实际上暗含多种含义，其一是元组记录的值不会改变，其二是元组记录的值的顺序不会改变。第二条相当重要，但是常被忽略。有些时候单纯的数值没有意义，只有结合值与该值在序列中的位置才会有明确的意义（例如经纬度记录，抑或是按照一定顺序采集到的数据）。

拆包让元组可以完美地被当作记录来使用

元组拆包

拆包可以以多种方式进行：

• 平行赋值：对于一个可迭代对象，使用相同数量的变量接收其中的元素
• * 运算符拆包：* 可以将一个可迭代对象拆包并作为传入函数的参数
• * 运算符处理剩余元素：* 除了可以拆包可迭代对象外，还可以用于接收不确定数量的拆包结果
  • 非常神奇的功能，类似于 *args。赋值表达式的左边最多只能由一个 *，并且带有 * 运算符的变量总会自动接受合适数量的拆包结果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# * 运算符处理剩余元素
>>> a, b, *rest = range(5)
>>> a, b, rest
(0, 1, [2, 3, 4])

>>> a, b, *rest = range(3)
>>> a, b, rest
(0, 1, [2])

>>> a, b, *rest = range(2)
>>> a, b, rest
(0, 1, [])

>>> a, *body, c, d = range(5)
>>> a, body, c, d
(0, [1, 2], 3, 4)

>>> *head, b, c, d = range(5)
>>> head, b, c, d
([0, 1], 2, 3, 4)

嵌套元组拆包

接受表达式的元组可以是嵌套式的，例如 (a, b, (c, d))。只要这个接受元组的嵌套结构符合表达式本身的嵌套结构，Python 就可以作出正确的对应。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

metro_areas = [
    ('Tokyo','JP',36.933,(35.689722,139.691667)),  
    ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)),
    ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)),
    ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)),
    ('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)),
]

print('{:15} | {:^9} | {:^9}'.format('', 'lat.', 'long.'))
fmt = '{:15} | {:9.4f} | {:9.4f}'
for name, cc, pop, (latitude, longitude) in metro_areas: 
    if longitude <= 0:  
        print(fmt.format(name, latitude, longitude))

具名元组

有些情况下，我们希望元组能带有一个可以解释各位置数据的含义的字段。collections.namedtuple 即可实现这一功能

namedtuple 实际上创建了一个类

用 namedtuple 构建的类的实例所消耗的内存跟元组是一样的，因为字段名都被存在对应的类里面。这个实例跟普通的对象实例比起来也要小一些，因为 Python 不会用 __dict__ 来存放这些实例的属性。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

>>> from collections import namedtuple
# 创建一个具名元组需要两个参数，一个是类名，另一个是类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串。
>>> City = namedtuple('City', 'name country population coordinates')  
# or
>>> City = namedtuple('City', ['name', 'country', 'population', 'coordinates']) 

>>> tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))  ➋
>>> tokyo
City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722,
139.691667))
>>> tokyo.population  ➌
36.933
>>> tokyo.coordinates
(35.689722, 139.691667)
>>> tokyo[1]
'JP'

使用 collections.namedtuple 创建的类的实例可以使用对应的字段名或者索引来获取对应的值。此外，还有如下常用功能：

• ._fields：返回包括所有字段名称的元组
• ._make()：接受一个可迭代对象以生成一个实例
• ._asdict()：将具名元组以 collections.OrderedDict 形式返回 —— [(key1, value1), (key2, value2), ...]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

>>> City._fields  ➊
('name', 'country', 'population', 'coordinates')

>>> LatLong = namedtuple('LatLong', 'lat long')
>>> delhi_data = ('Delhi NCR', 'IN', 21.935, LatLong(28.613889, 77.208889))
>>> delhi = City._make(delhi_data)  ➋

>>> delhi._asdict()  ➌
OrderedDict([('name', 'Delhi NCR'), ('country', 'IN'), ('population',
21.935), ('coordinates', LatLong(lat=28.613889, long=77.208889))])
>>> for key, value in delhi._asdict().items():
        print(key + ':', value)

name: Delhi NCR
country: IN
population: 21.935
coordinates: LatLong(lat=28.613889, long=77.208889)

切片

为什么切片和区间会忽略最后一个元素

• 当只有最后一个位置信息时，我们也可以快速看出切片和区间里有几个元素：range(3) 和 my_list[:3] 都返回 3 个元素。
• 当起止位置信息都可见时，我们可以快速计算出切片和区间的长度，用后一个数减去第一个下标（stop - start）即可。
• 这样做也让我们可以利用任意一个下标来把序列分割成不重叠的两部分，只要写成 my_list[:x] 和 my_list[x:] 就可以了

这些理由对我不是很有说服力……

具有名称标识的切片操作

1

slice(startIndex, endIndex, step=1)

这个用法很实用，主要是能够对切片操作进行单独的定义。方便对不同的序列使用相同的切片操作进行切片。同样的，slice 对象也会忽略最后一个元素

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 纯文本文件形式的收据以一行字符串的形式被解析
>>> invoice = """
... 0.....6................................40........52...55........
... 1909  Pimoroni PiBrella                    $17.50    3    $52.50
... 1489  6mm Tactile Switch x20                $4.95    2     $9.90
... 1510  Panavise Jr. - PV-201                $28.00    1    $28.00
... 1601  PiTFT Mini Kit 320x240               $34.95    1    $34.95
... """

>>> SKU = slice(0, 6)
>>> DESCRIPTION = slice(6, 40)
>>> UNIT_PRICE = slice(40, 52)
>>> QUANTITY = slice(52, 55)
>>> ITEM_TOTAL = slice(55, None)

>>> line_items = invoice.split('\n')[2:]
>>> for item in line_items:
...     print(item[UNIT_PRICE], item[DESCRIPTION])
...
    $17.50   Pimoroni PiBrella
     $4.95   6mm Tactile Switch x20
    $28.00   Panavise Jr. - PV-201
    $34.95   PiTFT Mini Kit 320x240

多维切片和省略

多维切片在处理实际数据时经常用到，例如处理图像数据或者更高维的数据。Python 内置的序列类型均是一维的，因此内置的序列类型仅支持一维的。

[] 运算符里还可以使用以逗号分开的多个索引或者是切片，外部库 NumPy 里就用到了这个特性，二维的 numpy.ndarray 就可以用 a[i, j] 这种形式来获取，抑或是用 a[m:n, k:l] 的方式来得到二维切片。

要正确处理这种 [] 运算符的话，对象的特殊方法 __getitem__ 和 __setitem__ 需要以元组的形式来接收 a[i, j] 中的索引。也就是说，如果要得到 a[i, j] 的值，Python 会调用 a.__getitem__((i, j))。

总的来说，若想实现多维切片，需要实现 __getitem__ 和 __setitem__ 。前者用于读取数据，后者用于赋值。

省略符号（…）则被用于省略无需额外指定的参数。例如，对于一个四维数组，若仅对第一维和最后一维进行切片，在 Numpy 可以写为：

1
2

test_list[i, ..., j]
test_list[i:j, ..., k:z]

这些句法上的特性主要是为了支持用户自定义类或者扩展，比如 NumPy 就是个例子。

给切片赋值

若赋值的对象是一个切片，则赋值语句的右侧也必须是一个可迭代对象

但是在 Numpy 等库中，则可以直接用单个数值对切片进行赋值，这一操作主要依赖 Numpy 等库中的 broadcast 机制；基于 broadcast 机制，一些 shape 没有完全对应上的情况在 Numpy 中也可以进行赋值和运算

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

>>> l = list(range(10))
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> l[2:5] = [20, 30]
>>> l
[0, 1, 20, 30, 5, 6, 7, 8, 9]

>>> del l[5:7]
>>> l
[0, 1, 20, 30, 5, 8, 9]

# 从下标3开始，每2步长替换一次
>>> l[3::2] = [11, 22] 
>>> l
[0, 1, 20, 11, 5, 22, 9]

>>> l[2:5] = 100  
# 如果赋值的对象是一个切片，那么赋值语句的右侧必须是个可迭代对象。即便只有单独一个值，也要把它转换成可迭代的序列。
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only assign an iterable

>>> l[2:5] = [100]
>>> l
[0, 1, 100, 22, 9]

✅ 一个有趣的极限情况

1
2

test_tuple = (1, 2, [3, 4])
test_tuple[2] += [5, 6]

上述操作按理来说应当是直接报错，因为元组中的元素不可赋值。但是实际情况是报错的同时，元组包含的列表被修改了。

对上述代码的字节码进行分析可以发现，顺序执行了下述三个操作

1. 读取 test_tuple[2] 并将其存入栈顶，记为 TOS
2. 完成操作 TOS += [5, 6]
3. 将结果存入原位置：test_tuple[2] = TOS

其中，第二步是对 list 进行的操作，由于 list 是可变序列因此该操作不会报错；第三步是对 tuple 进行的操作，由于 tuple 是不可变序列，当尝试赋值时会抛出错误。但是 tuple 中存放的是 list 的引用，因此此时 tuple 中的 list 实际上已经被修改。

上述结果反映：

1. 将可变对象放置于不可变对象中是十分危险的操作
2. 上述操作不是原子操作，因此发生了上述既完成了操作又抛出了错误的结果。

序列的增量赋值

+= 背后的特殊方法是 __iadd__ （用于“就地加法”）。但是如果一个类没有实现这个方法的话，Python 会退一步调用 __add__ 。考虑下面这个简单的表达式：

1

>>> a += b

如果 a 实现了 __iadd__ 方法，就会调用这个方法。同时对可变序列（例如 list、bytearray 和 array.array）来说，a 会就地改动，就像调用了 a.extend(b) 一样。但是如果 a 没有实现 __iadd__ 的话，a += b 这个表达式的效果就变得跟 a = a + b 一样了：首先计算 a + b，得到一个新的对象，然后赋值给 a。也就是说，在这个表达式中，变量名会不会被关联到新的对象，完全取决于这个类型有没有实现 __iadd__ 这个方法。

总体来讲，可变序列一般都实现了 __iadd__ 方法，因此 += 是就地加法。而不可变序列根本就不支持这个操作，对这个方法的实现也就无从谈起。

上面所说的这些关于 += 的概念也适用于 *=，后者相对应的是 __imul__。

接下来有个小例子，展示的是 *= 在可变和不可变序列上的作用：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

>>> l = [1, 2, 3]
>>> id(l)
4311953800
>>> l *= 2
>>> l
[1, 2, 3, 1, 2, 3]
>>> id(l)
4311953800 # 可变序列的增量赋值，id不变

>>> t = (1, 2, 3)
>>> id(t)
4312681568
>>> t *= 2
>>> id(t)
4301348296  # 不可变序列的增量赋值，id改变

✅ 规律：

• 可变序列的增量赋值，id 不变
• 不可变序列的增量赋值，id 改变

对不可变序列进行重复拼接操作的话，效率会很低，因为每次都有一个新对象，而解释器需要把原来对象中的元素先复制到新的对象里，然后再追加新的元素。

str 是一个例外，因为对字符串做 += 实在是太普遍了，所以 CPython 对它做了优化。为 str 初始化内存的时候，程序会为它留出额外的可扩展空间，因此进行增量操作的时候，并不会涉及复制原有字符串到新位置这类操作。

有序序列的元素查找以及插入

bisect 模块提供了对有序序列进行元素查找以及插入的方法。

• bisect.bisect 可以用于元素插入位置查找：寻找一个位置，使得插入待插入元素后，有序序列仍是有序的。
• bisect.insort 函数则直接将元素插入有序序列中。

bisect() 和 insort() 均有两种形式，分别被命名为 _right，_left。若遇到相等的元素，_right 会将元素插入到序列中相同值的元素的后面，而 _left 则会插入到前面。

bisect 函数其实是 bisect_right 函数的别名

1
2
3
4
5
6

>>> def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'):
...     i = bisect.bisect(breakpoints, score)
...     return grades[i]
...
>>> [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]
['F', 'A', 'C', 'C', 'B', 'A', 'A']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

import bisect
import random

SIZE=7

random.seed(1729)

my_list = []
for i in range(SIZE):
    new_item = random.randrange(SIZE*2)
    bisect.insort(my_list, new_item)
    print('%2d ->' % new_item, my_list)

1
2
3
4
5
6
7

10 -> [10]
 0 -> [0, 10]
 6 -> [0, 6, 10]
 8 -> [0, 6, 8, 10]
 7 -> [0, 6, 7, 8, 10]
 2 -> [0, 2, 6, 7, 8, 10]
10 -> [0, 2, 6, 7, 8, 10, 10]

insort 跟 bisect 一样，有 lo 和 hi 两个可选参数用来控制查找的范围。它也有个变体叫 insort_left，这个变体在背后用的是 bisect_left。

当列表不是首选时

虽然列表既灵活又简单，但面对各类需求时，我们可能会有更好的选择。

比如，要存放 1000 万个浮点数的话，数组（array）的效率要高得多，因为数组在背后存的并不是 float 对象，而是数字的机器翻译，也就是字节表述。这一点就跟 C 语言中的数组一样。

再比如说，如果需要频繁对序列做先进先出的操作，deque（双端队列）的速度应该会更快。

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

数组

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

1
2

from array import array  
test_array = array(type, data)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 一个浮点型数组的创建、存入文件和从文件读取的过程

>>> from array import array  
>>> from random import random
>>> 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)  
>>> fp.close()
>>> floats2[-1]  
0.07802343889111107
>>> floats2 == floats  
True

一个小试验告诉我，用 array.fromfile 从一个二进制文件里读出 1000 万个双精度浮点数只需要 0.1 秒，这比从文本文件里读取的速度要快 60 倍，因为后者会使用内置的 float 方法把每一行文字转换成浮点数。

另外，使用 array.tofile 写入到二进制文件，比以每行一个浮点数的方式把所有数字写入到文本文件要快 7 倍。另外，1000 万个这样的数在二进制文件里只占用 80 000 000 个字节（每个浮点数占用 8 个字节，不需要任何额外空间），如果是文本文件的话，我们需要 181 515 739 个字节。

内存视图

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

实际上提供了一种在不需要赋值内容的前提下，实现不同数据结构之间的内存共享。即指定一块区域，能够使用不同的方式去存读数据，例如可以以 list 的形式创建一个序列，然后以 Numpy array 的形式去处理这个序列，而不需要额外再创建一个包含相同内容的新 array。

1
2
3
4
5
6
7
8
9

>>>v = memoryview(bytearray("abcefg", 'utf-8'))
>>> print(v[1])
98
>>> print(v[-1])
103
>>> print(v[1:4])
<memory at 0x10f543a08>
>>> print(v[1:4].tobytes())
b'bce'

双向队列

利用 .append 和 .pop 方法，我们可以把列表当作栈或者队列来用（比如，把 .append 和 .pop(0) 合起来用，就能模拟栈的“先进先出”的特点）。

但是删除列表的第一个元素（抑或是在第一个元素之前添加一个元素）之类的操作是很耗时的，因为这些操作会牵扯到移动列表里的所有元素。

collections.deque 类（双向队列）是一个线程安全、可以快速从两端添加或者删除元素的数据类型。

而且如果想要有一种数据类型来存放“最近用到的几个元素”，deque 也是一个很好的选择。

这是因为在新建一个双向队列的时候，你可以指定这个队列的大小，如果这个队列满员了，还可以从反向端删除过期的元素，然后在尾端添加新的元素。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from collections import deque

dq = deque(range(10), maxlen=10)
print(dq)
# ------------------ 旋转元素 ------------------0
print("\n将后3个数移动到队列头部:")
dq.rotate(3)
print(dq)
print("\n将前4个数移动到队列尾部:")
dq.rotate(-4)
print(dq)
print("\n从头部添加元素：")
dq.appendleft(-1)
print(dq)
print("\n从尾部添加元素：")
dq.append(-1)
print(dq)
print("\n从尾部逐项添加元素：")
dq.extend([10, 20, 30, 40])
print(dq)
print("\n从头部逐项添加元素：")
dq.extendleft([10, 20, 30, 40])
print(dq)

output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)

将后3个数移动到队列头部:
deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)

将前4个数移动到队列尾部:
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([1, 2, 3, 4, 5, 6, 7, 8, 9, -1], maxlen=10)

从尾部逐项添加元素：
deque([5, 6, 7, 8, 9, -1, 10, 20, 30, 40], maxlen=10)

从头部逐项添加元素：
deque([40, 30, 20, 10, 5, 6, 7, 8, 9, -1], maxlen=10)

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

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

其他

• 对 seq[start:stop:step] 进行求值的时候，Python 会调用 seq.__getitem__(slice(start, stop, step))

• key 参数能让你对一个混有数字字符和数值的列表进行排序。你只需要决定到底是把字符看作数值，还是把数值看作字符：

  1 2 3 4 5

  >>> l = [28, 14, '28', 5, '9', '1', 0, 6, '23', 19] >>> sorted(l, key=int) [0, '1', 5, 6, '9', 14, 19, '23', 28, '28'] >>> sorted(l, key=str) [0, '1', 14, 19, '23', 28, '28', 5, 6, '9']

字典和集合

字典这个数据结构活跃在所有 Python 程序的背后，即便你的源码里并没有直接用到它

跟字典有关的内置函数都在 __builtins__.__dict__ 模块中。

正是因为字典至关重要，Python 对它的实现做了高度优化，而散列表则是字典类型性能出众的根本原因。

泛映射（mapping）类型

字典属于泛映射类型数据结构，不同于序列类型，字典总是由 key-value（键值对）构成。

collections.abc 中定义了 Mapping 和 MutableMapping 两个抽象基类，这些基类为 dict 等数据结构定义了形式接口。

箭头由子类指向超类

这些基类主要是作为形式化的文档并定义里构建一个映射类型需要的最基本接口。使用 isinstance 就可以判断某一个对象是否是广义上的映射类型。

1
2
3

>>> my_dict = {}
>>> isinstance(my_dict, abc.Mapping)
True

可散列的数据类型

散列函数的使用能够更快速的访问某一特定关键字对应的数据。

如果一个对象是可散列的，那么在这个对象的生命周期中，它的散列值是不变的，而且这个对象需要实现 __hash__() 方法和 __qe__() 方法，这样才能跟其他键做比较。

如果两个可散列对象是相等的，那么它们的散列值一定是一样的。

原子不可变数据类型（str、bytes 和数值类型）都是可散列类型，frozenset 也是可散列的，因为根据其定义，frozenset 里只能容纳可散列类型。

元组的话，只有当一个元组包含的所有元素都是可散列类型的情况下，它才是可散列的。来看下面的元组 tt、tl 和 tf：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

>>> tt = (1, 2, (30, 40))
>>> hash(tt)
8027212646858338501
>>> tl = (1, 2, [30, 40])
>>> hash(tl)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> tf = (1, 2, frozenset([30, 40]))
>>> hash(tf)
-4118419923444501110

一般来讲用户自定义的类型的对象都是可散列的，散列值就是它们的 id() 函数的返回值，所以所有这些对象在比较的时候都是不相等的。

如果一个对象实现了 __eq__ 方法，并且在方法中用到了这个对象的内部状态的话，那么只有当所有这些内部状态都是不可变的情况下，这个对象才是可散列的。

根据这些定义，字典提供了很多种构造方法，“Built-in Types”

1
2
3
4
5
6
7

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True

常见的映射方法

映射的弹性键查询

get() & setdefault()

get() 能够规避对 dict 中某一个 key 赋值时，由于 key 不存在于 dict 中导致的 keyError。但是利用 get() 方法处理这种情况需要经过多次键查询操作（get() 是一次，然后赋值又是一次，并且还需要创建临时变量用于存放取得的值以及对值的操作）

setdefault() 则可以一步完成上述工作

1
2
3
4
5

my_dict.get(key, [])
my_dict.setdefault(key, []) # 更高效

if key not in my_dict:
    my_dict[key] = []

但有时候为了方便起见，就算某个键在映射里不存在，我们也希望在通过这个键读取值的时候能得到一个默认值。有两个途径能帮我们达到这个目的：

• 一个是通过 defaultdict 这个类型而不是普通的 dict
• 另一个是给自己定义一个 dict 的子类，然后在子类中实现 __missing__ 方法。

下面将介绍这两种方法。

defaultdict

有些时候，希望某个键不存在于映射中也会返回一个默认值，collections.defaultdict 实现了 __missing__ 方法，用于应对这种需求。

defaultdict 会按照如下步骤处理映射类型中不存在的键

• 调用定义时指定的方法，创建一个新的对象（例如，若默认创建一个列表类型，则会调用 list() 方法创建一个新 list）
• 将新对象作为值，构建键值对并记录到原字典中
• 返回新创建的键值对的值的引用

1
2

# 把 list 构造方法作为 default_factory 来创建一个 defaultdict
my_dict = collections.defaultdict(list)

defaultdict 依赖 default_factory 方法实现上述操作，值得注意的是，defaultfactory 仅会在 __getitem__ 中被调用，对于一个不存在于字典中的键 “new_key”，若直接用 get() 函数获取其对应的值则会返回 None。

__getitem__ 并不会直接调用 default_factory，而是按照如下流程进行调用：

• 执行 defaultdict["new_key"]，希望获得 “new_key” 对应的值
• 调用 __getitem__() 方法，结果没有在键列表中查询到 “new_key”
• 调用 __missing__() 方法，处理未知键 “new_key”
• 调用 default_factory() 方法，赋予 “new_key” 默认值

上述流程中最为关键的是 __missing__() 方法的实现。它会在 defaultdict 遇到找不到的键的时候调用 default_factory。

自定义 __missing__

实际上，对于自定义的映射数据类型，若想处理未知键的查询和创建任务，也仅需要实现 __missing__() 方法就好。

1
2
3
4
5
6
7
8
9

class TestDict(dict):
    # 其他代码，省略

    def __missing__(self, key):
        print("call __missing__")
        # 新增 key 
        self[key] = "default"
	# 返回该项
        return "default"

如果要自定义一个映射类型，更合适的策略其实是继承 collections.UserDict 类（示例 3-8 就是如此）。这里我们从 dict 继承，只是为了演示 __missing__ 是如何被 dict.__getitem__ 调用的。

字典的变种

dict 类型是最常用的映射类型，defaultdict 和 OrderedDict 则是 dict 的变种，这两个类型支持一些特殊的用法。此外还有如 ChainMap（可容纳多个映射对象并在进行键查找时，在所有的映射对象中进行查找）、Counter（具有计数器功能，相当适用于计数任务）、UserDict（开箱即用的自定义映射类型基类）等

总的来说，这些变种均具有 dict 具有的功能，此外还为了应对不同的应用场合提供了更为丰富的功能。

collections.defaultdict

defaultdict 对未知键提供了特殊支持，当传入字典中不存在的键获取数据时，dict 会直接报错，而 defaultdict 则会默认为这个新键创建对应的键值对（在建立字典的时候非常非常非常好用，之前都是首先用 if 判断字典中是否存在该键，然后根据判断结果创建或者修改键值对）

collections.OrderedDict

OrderedDict 则对顺序提供了额外支持，普通的 dict 并不会记录键值对的顺序，或者说 dict 中的键值对都是无序的，但是 OrderedDict 则提供了额外的键值对顺序功能支持，支持类似于先入先出的功能。

OrderedDict 的 popitem 方法默认删除并返回的是字典里的最后一个元素，但是如果像 my_odict.popitem(last=False) 这样调用它，那么它删除并返回第一个被添加进去的元素。

collections.ChainMap

详见 https://www.cnblogs.com/mangmangbiluo/p/9882097.html

该类型可以容纳数个不同的映射对象，然后在进行键查找操作的时候，这些对象会被当作一个整体被逐个查找，直到键被找到为止。这个功能在给有嵌套作用域的语言做解释器的时候很有用，可以用一个映射对象来代表一个作用域的上下文。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from collections import ChainMapa = {"x":1, "z":3}
b = {"y":2, "z":4}
c = ChainMap(a,b)
print(c)
print("x: {}, y: {}, z: {}".format(c["x"], c["y"], c["z"]))

输出：
ChainMap({'x': 1, 'z': 3}, {'y': 2, 'z': 4})
x: 1, y: 2, z: 3
[Finished in 0.1s]

这是 ChainMap 最基本的使用，可以用来合并两个或者更多个字典，当查询的时候，从前往后依次查询。

从原理上面讲，ChainMap 实际上是把放入的字典存储在一个队列中，当进行字典的增加删除等操作只会在第一个字典上进行，当进行查找的时候会依次查找

有一个注意点就是当对 ChainMap 进行修改的时候总是只会对第一个字典进行修改

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

In [6]: a = {"x":1, "z":3}

In [7]: b = {"y":2, "z":4}

In [8]: c = ChainMap(a, b)

In [9]: c
Out[9]: ChainMap({'z': 3, 'x': 1}, {'z': 4, 'y': 2})

In [10]: c["z"]
Out[10]: 3

In [11]: c["z"] = 4

In [12]: c
Out[12]: ChainMap({'z': 4, 'x': 1}, {'z': 4, 'y': 2})

In [13]: c.pop('z')
Out[13]: 4

In [14]: c
Out[14]: ChainMap({'x': 1}, {'z': 4, 'y': 2})

In [15]: del c["y"]
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
。。。。。。
KeyError: "Key not found in the first mapping: 'y'"

collections.Counter

这个映射类型会给键准备一个整数计数器。每次更新一个键的时候都会增加这个计数器。

所以这个类型可以用来给可散列表对象计数，或者是当成多重集来用——多重集合就是集合里的元素可以出现不止一次。

Counter 实现了 + 和 - 运算符用来合并记录，还有像 most_common([n]) 这类很有用的方法。most_common([n]) 会按照次序返回映射里最常见的 n 个键和它们的计数

下面的小例子利用 Counter 来计算单词中各个字母出现的次数：

1
2
3
4
5
6
7
8

>>> ct = collections.Counter('abracadabra')
>>> ct
Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})
>>> ct.update('aaaaazzz')
>>> ct
Counter({'a': 10, 'z': 3, 'b': 2, 'r': 2, 'c': 1, 'd': 1})
>>> ct.most_common(2)
[('a', 10), ('z', 3)]

UserDict

这个类其实就是把标准 dict 用纯 Python 又实现了一遍。

跟 OrderedDict、ChainMap 和 Counter 这些开箱即用的类型不同，UserDict 是让用户继承写子类的。

子类化 UserDict

而更倾向于从 UserDict 而不是从 dict 继承的主要原因是，后者有时会在某些方法的实现上走一些捷径，导致我们不得不在它的子类中重写这些方法，但是 UserDict 就不会带来这些问题

另外一个值得注意的地方是，UserDict 并不是 dict 的子类，但是 UserDict 有一个叫作 data 的属性，是 dict 的实例，这个属性实际上是 UserDict 最终存储数据的地方。这样做的好处是，比起示例 3-7，UserDict 的子类就能在实现 __setitem__ 的时候避免不必要的递归，也可以让 __contains__ 里的代码更简洁。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import collections

class StrKeyDict(collections.UserDict):

    def __missing__(self, key):
        if isinstance(key, str):
            raise KeyError(key)
        return self[str(key)]

    def __contains__(self, key):
        return str(key) in self.data  

    def __setitem__(self, key, item):
        self.data[str(key)] = item

不可变的映射类型

从 Python 3.3 开始，types 模块中引入了一个封装类名叫 MappingProxyType。如果给这个类一个映射，它会返回一个只读的映射视图。

虽然是个只读视图，但是它是动态的。这意味着如果对原映射做出了改动，我们通过这个视图可以观察到，但是无法通过这个视图对原映射做出修改。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

>>> from types import MappingProxyType
>>> d = {1:'A'}
>>> d_proxy = MappingProxyType(d)
>>> d_proxy
mappingproxy({1: 'A'})
>>> d_proxy[1]  # d 中的内容可以通过 d_proxy 看到
'A'
>>> d_proxy[2] = 'x'  # 但是通过 d_proxy 并不能做任何修改
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'mappingproxy' object does not support item assignment
>>> d[2] = 'B'
>>> d_proxy # d_proxy 是动态的，也就是说对 d 所做的任何改动都会反馈到它上面
mappingproxy({1: 'A', 2: 'B'})
>>> d_proxy[2]
'B'

集合

集合在 Python 中是一个较新的概念，其描述了唯一对象的集合。集合有如下特点：

1. 元素的唯一性：集合中不会有两个一样的对象（这里的唯一性指的是 hash 的唯一性）
2. 集合中的元素必须是可散列的，但是**set 本身是不可散列的**，set 类型本身是不可散列的，但是 frozenset 可以。因此可以创建一个包含不同 frozenset 的 set。
3. 集合允许各种基于集合的二元运算，例如交集、并集以及差集
   • a | b 返回的是它们的合集，a & b 得到的是交集，而 a - b 得到的是差集。

集合的字面量

1
2
3
4
5
6
7
8
9

>>> s = {1}
>>> type(s)
<class 'set'>
>>> s
{1}
>>> s.pop()
1
>>> s
set()

像 {1, 2, 3} 这种字面量句法相比于构造方法（set([1, 2, 3])）要更快且更易读。后者的速度要慢一些，因为 Python 必须先从 set 这个名字来查询构造方法，然后新建一个列表，最后再把这个列表传入到构造方法里。但是如果是像 {1, 2, 3} 这样的字面量，Python 会利用一个专门的叫作 BUILD_SET 的字节码来创建集合。

用 dis.dis（反汇编函数）来看看两个方法的字节码的不同：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

>>> from dis import dis
>>> dis('{1}')                                  ➊
  1           0 LOAD_CONST             0 (1)
              3 BUILD_SET              1        ➋
              6 RETURN_VALUE
>>> dis('set([1])')                             ➌
  1           0 LOAD_NAME              0 (set)  ➍
              3 LOAD_CONST             0 (1)
              6 BUILD_LIST             1
              9 CALL_FUNCTION          1 (1 positional, 0 keyword pair)
             12 RETURN_VALUE

➊ 检查 {1} 字面量背后的字节码。

➋ 特殊的字节码 BUILD_SET 几乎完成了所有的工作。

➌ set([1]) 的字节码。

➍ 3 种不同的操作代替了上面的 BUILD_SET：LOAD_NAME、BUILD_LIST 和 CALL_FUNCTION。

集合推导

1
2
3
4

>>> from unicodedata import name  # 从 unicodedata 模块里导入 name 函数，用以获取字符的名字
>>> {chr(i) for i in range(32, 256) if 'SIGN' in name(chr(i),'')}  
{'§', '=', '¢', '#', '¤', '<', '¥', 'μ', '×', '$', '¶', '£', '©',
'°', '+', '÷', '±', '>', '¬', '®', '%'}

dict 和 set 的背后

散列表其实是一个稀疏数组（总是有空白元素的数组称为稀疏数组）。在一般的数据结构教材中，散列表里的单元通常叫作表元（bucket）。在 dict 的散列表当中，每个键值对都占用一个表元，每个表元都有两个部分，一个是对键的引用，另一个是对值的引用。因为所有表元的大小一致，所以可以通过偏移量来读取某个表元。

因为 Python 会设法保证大概还有三分之一的表元是空的，所以在快要达到这个阈值的时候，原有的散列表会被复制到一个更大的空间里面。

如果要把一个对象放入散列表，那么首先要计算这个元素键的散列值。Python 中可以用 hash() 方法来做这件事情。

散列值和相等性

内置的 hash() 方法可以用于所有的内置类型对象。如果是自定义对象调用 hash() 的话，实际上运行的是自定义的 __hash__。

如果两个对象在比较的时候是相等的，那它们的散列值必须相等，否则散列表就不能正常运行了。例如，如果 1 == 1.0 为真，那么 hash(1) == hash(1.0) 也必须为真，但其实这两个数字（整型和浮点）的内部结构是完全不一样的

为了让散列值能够胜任散列表索引这一角色，它们必须在索引空间中尽量分散开来。这意味着在最理想的状况下，越是相似但不相等的对象，它们散列值的差别应该越大。

总结一下，一个可散列的对象必须满足以下要求。

1. 支持 hash() 函数，并且通过 __hash__() 方法所得到的散列值是不变的。
2. 支持通过 __eq__() 方法来检测相等性。
3. 若 a == b 为真，则 hash(a) == hash(b) 也为真。

所有由用户自定义的对象默认都是可散列的，因为它们的散列值由 id() 来获取，而且它们都是不相等的

如果你实现了一个类的 __eq__ 方法，并且希望它是可散列的，那么它一定要有个恰当的 __hash__ 方法，保证在 a == b 为真的情况下 hash(a) == hash(b) 也必定为真。否则就会破坏恒定的散列表算法，导致由这些对象所组成的字典和集合完全失去可靠性，这个后果是非常可怕的。

另一方面，如果一个含有自定义的 __eq__ 依赖的类处于可变的状态，那就不要在这个类中实现 __hash__ 方法，因为它的实例是不可散列的。

一个例子

在 32 位的 Python 中，1、1.0001、1.0002 和 1.0003 这几个数的散列值的二进制表达对比（上下两个二进制间不同的位被 ! 高亮出来，表格的最右列显示了有多少位不相同）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

32-bit Python build
1        00000000000000000000000000000001
                                          != 0
1.0      00000000000000000000000000000001
------------------------------------------------
1.0      00000000000000000000000000000001
           ! !!! ! !! ! !    ! ! !! !!!   != 16
1.0001   00101110101101010000101011011101
------------------------------------------------
1.0001   00101110101101010000101011011101
          !!!  !!!! !!!!!   !!!!! !!  !   != 20
1.0002   01011101011010100001010110111001
------------------------------------------------
1.0002   01011101011010100001010110111001
          ! !   ! !!! ! !  !! ! !  ! !!!! != 17
1.0003   00001100000111110010000010010110
------------------------------------------------

从 Python 3.3 开始，str、bytes 和 datetime 对象的散列值计算过程中多了随机的“加盐”这一步。所加盐值是 Python 进程内的一个常量，但是每次启动 Python 解释器都会生成一个不同的盐值。随机盐值的加入是为了防止 DOS 攻击而采取的一种安全措施。

散列表算法

为了获取 my_dict[search_key] 背后的值，Python 首先会调用 hash(search_key) 来计算 search_key 的散列值，把这个值最低的几位数字当作偏移量，在散列表里查找表元（具体取几位，得看当前散列表的大小）。若找到的表元是空的，则抛出 KeyError 异常。若不是空的，则表元里会有一对 found_key:found_value。这时候 Python 会检验 search_key == found_key 是否为真，如果它们相等的话，就会返回 found_value。

如果 search_key 和 found_key 不匹配的话，这种情况称为散列冲突。发生这种情况是因为，散列表所做的其实是把随机的元素映射到只有几位的数字上，而散列表本身的索引又只依赖于这个数字的一部分。为了解决散列冲突，算法会在散列值中另外再取几位，然后用特殊的方法处理一下，把新得到的数字再当作索引来寻找表元；若这次找到的表元是空的，则同样抛出 KeyError；若非空，或者键匹配，则返回这个值；或者又发现了散列冲突，则重复以上的步骤。

总结一下：

1. 计算键的散列值
2. 使用散列值的一部分来定位散列表中的一个表元
3. 判断表元是否为空
   • 若为空，抛出 KeyError
   • 若不为空，执行第 4 步
4. 检查是否是期望的元素
   • 若是期望的元素，返回表元中的值
   • 若不是期望的元素，执行第 5 步
5. 发生冲突，使用散列值的另一部分来定位散列表中的另一行，并返回第 3 步

添加新元素和更新现有键值的操作几乎跟查找一样。只不过对于前者，在发现空表元的时候会放入一个新元素；对于后者，在找到相对应的表元后，原表里的值对象会被替换成新值。。此外，为了保证散列表的稀疏性，当元素数量增添到一定阈值时，Python 会自动将这个散列表复制到更大的空间中以避免冲突。

一些特点

字典在内存上的开销巨大

由于字典使用了散列表，而散列表又必须是稀疏的，这导致它在空间上的效率低下。

举例而言，如果你需要存放数量巨大的记录，那么放在由元组或是具名元组构成的列表中会是比较好的选择；最好不要根据 JSON 的风格，然后用字典组成的列表来存放这些记录。

用元组取代字典就能节省空间的原因有两个：其一是避免了散列表所耗费的空间，其二是无需把记录中字段的名字在每个元素里都存一遍。

在用户自定义的类型中，__slots__ 属性可以改变实例属性的存储方式，由 dict 变成 tuple

总结

1. 正是由于 dict 和 set 使用散列表来进行数据存储，在进行元素查找时不需要对所有元素进行遍历，这使得搜索特定元素的效率大大提高。
   • 并且由于稀疏性，查找时间不会随着 dict 和 set 中元素数量的增加而线性增长。
2. 由于使用散列表进行存储，dict 和 set 中的元素也没有固定的顺序，在添加新元素时原有的顺序可能会被改变
3. dict 和 set 使用散列表进行数据存储，因此这两个数据类型要求元素时可散列的。
   • 即，在 Python 中某元素必须支持 __hash__() 函数，并且通过 __hash__() 函数取得的散列值在生命周期中不发生变化。
   • 此外，Python 还要求可散列的元素支持 __eq__() 方法以判断相等性。这些条件使得不是所有的对象均可以作为 dict 的键或者 set 的元素。
4. 与 2 类似，由于添加元素后很可能改变原有的顺序，因此在 dict 和 set 中讨论元素的顺序没有意义，除非使用类似于 OrderedDict 这样的特殊类型。
5. 由于元素的顺序不确定，在循环迭代 dict 或者 set 的同时删增元素可能会导致跳过某些元素。
   1. 若使用 .keys()、.values() 以及 .items() 等函数对 dict 进行循环迭代，Python3 中这些方法返回的字典视图具有动态的特性。即，循环迭代过程中对 dict 的改变会实时反馈到循环条件上，这显然会导致不可预测的错误。
6. dict 和 set 是空间换时间的典型例子。散列表需要保证稀疏性以尽可能避免冲突
   • 因此，相较于 list，dict 和 set 需要维护更大的内存空间以保证散列表的稀疏性

其他

• 像 k in my_dict.keys() 这种操作在 Python 3 中是很快的，而且即便映射类型对象很庞大也没关系。这是因为 dict.keys() 的返回值是一个 “视图”。
  • 视图就像一个集合，而且跟字典类似的是，在视图里查找一个元素的速度很快。Python 2 的 dict.keys() 返回的是个列表，因此虽然上面的方法仍然是正确的，它在处理体积大的对象的时候效率不会太高，因为 k in my_list 操作需要扫描整个列表。
• CPython 的实现细节里有一条是：如果有一个整型对象，而且它能被存进一个机器字中，那么它的散列值就是它本身的值
• 在散列冲突的情况下，用 C 语言写的用来打乱散列值位的算法的名字很有意思，叫 perturb。详见 CPython 源码里的 dictobject.c（https://hg.python.org/cpython/file/tip/Objects/dictobject.c）
• PHP 和 Ruby 的散列语法借鉴了 Perl，它们都用 => 作为键和值的连接。JavaScript 则从 Python 那儿偷师，使用了 :。而 JSON 又从 JavaScript 发展而来，它的语法正好是 Python 句法的子集。因此，除了在 true、false 和 null 这几个值的拼写上有出入之外，JSON 和 Python 是完全兼容的。于是，现在大家用来交换数据的格式全是 Python 的 dict 和 list。

文本和字节序列

本章将要讨论 Unicode 字符串、二进制序列，以及在二者之间转换时使用的编码

字符问题

字符串即字符的序列，重点是“字符”如何定义。

对于 Python，“字符” 即 Unicode 字符。字符的相关操作涉及到两个问题：

• 字符的标识，即码位，是特定字符在字符集中的唯一标识。
  • 码位是 0~1 114 111 的数字（十进制），在 Unicode 标准中以 4~6 个十六进制数字表示，而且加前缀“U+”。例如，字母 A 的码位是 U+0041，欧元符号的码位是 U+20AC，高音谱号的码位是 U+1D11E。
• 字符的字节表述，是字符的具体表述，通过特定的编码算法连接字符和对应的字节表述。
  • 在 UTF-8 编码中，A（U+0041）的码位编码成单个字节 \x41，而在 UTF-16LE 编码中编码成两个字节 \x41\x00。再举个例子，欧元符号（U+20AC）在 UTF-8 编码中是三个字节——\xe2\x82\xac，而在 UTF-16LE 中编码成两个字节：\xac\x20。

编码：将码位转换为字节序列的过程

解码：将字节序列转换为码位的过程

Python 对字符和字节进行了完全的区分，具体来说，所有的字节序列的字面量均会以特定标识开头。下述为编 / 解码的一个示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

>>> s = 'café'
>>> len(s)  
4
>>> b = s.encode('utf8')  
>>> b
b'caf\xc3\xa9'  
>>> len(b)  
5
>>> b.decode('utf8')  
'café

Python 3 的 str 类型基本相当于 Python 2 的 unicode 类型

Python 3 的 bytes 类型基本相当于 Python2 的 str 类型

字符串比较关键的问题是字符的编码算法以及文本文件的处理。前者涉及到的问题众多，而且相关的乱码问题时不时会出现，例如 matplotlib 的中文支持问题，后者则在读写文件时时常会遇到。

字节概要

bytes 是一种不可变数据类型，其元素是 0~255 之间的整数，并且 bytes 类型数据的切片依然是 bytes 类型。

bytearray 类型和 bytes 类型密切相关，bytearray 没有自己的字面量语法，但是和 bytes 类型的行为一致，其切片依然是 bytearray 类型。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

>>> cafe = bytes('café', encoding='utf_8') 
>>> cafe
b'caf\xc3\xa9'
>>> cafe[0] 
99
>>> cafe[:1] 
b'c'
>>> cafe_arr = bytearray(cafe)
>>> cafe_arr 
bytearray(b'caf\xc3\xa9')
>>> cafe_arr[-1:] 
bytearray(b'\xa9')

my_bytes[0] 获取的是一个整数，而 my_bytes[:1] 返回的是一个长度为 1 的 bytes 对象——这一点应该不会让人意外。s[0] == s[:1] 只对 str 这个序列类型成立。

不过，str 类型的这个行为十分罕见。对其他各个序列类型来说，s[i] 返回一个元素，而 s[i:i+1] 返回一个相同类型的序列，里面是 s[i] 元素。

字节的字面量表示

虽然二进制序列其实是整数序列，但是它们的字面量表示法表明其中有 ASCII 文本。因此，各个字节的值可能会使用下列三种不同的方式显示。

• 可打印的 ASCII 范围内的字节（从空格到 ~），使用 ASCII 字符本身。
• 制表符、换行符、回车符和 \ 对应的字节，使用转义序列 \t、\n、\r 和 \\。
• 其他字节的值，使用十六进制转义序列（例如，\x00 是空字节）。

因此，在上面的代码中 5，我们看到的是 b'caf\xc3\xa9'：前 3 个字节 b'caf' 在可打印的 ASCII 范围内，后两个字节则不然。

编解码器

Python 自带了相当数量的编解码器，常用的例如 utf-8、gbk 等

1
2
3
4
5
6

>>> for codec in ['latin_1', 'utf_8', 'utf_16']:
...     print(codec, 'El Niño'.encode(codec), sep='\t')
...
latin_1 b'El Ni\xf1o'
utf_8   b'El Ni\xc3\xb1o'
utf_16  b'\xff\xfeE\x00l\x00 \x00N\x00i\x00\xf1\x00o\x00'

编解码问题会导致一些异常的抛出：

1. UnicodeEncodeError：str 转 bytes 时
2. UnicodeDecodeError：bytes 转 str 时
3. SyntaxError：源码的编码错误

处理文本文件

处理文本的最佳实践是 “Unicode 三明治”

• 要尽早把输入（例如读取文件时）的字节序列解码成字符串。
• 这种三明治中的“肉片”是程序的业务逻辑，在这里只能处理字符串对象。在其他处理过程中，一定不能编码或解码。
• 对输出来说，则要尽量晚地把字符串编码成字节序列。

在 Python 3 中能轻松地采纳 Unicode 三明治的建议，因为内置的 open 函数会在读取文件时做必要的解码，以文本模式写入文件时还会做必要的编码，所以调用 my_file.read() 方法得到的以及传给 my_file.write(text) 方法的都是字符串对象

为了正确比较而规范化 Unicode 字符串

因为 Unicode 有组合字符（变音符号和附加到前一个字符上的记号，打印时作为一个整体），所以字符串比较起来很复杂。

例如，“café” 这个词可以使用两种方式构成，分别有 4 个和 5 个码位，但是结果完全一样：

1
2
3
4
5
6
7
8

>>> s1 = 'café'
>>> s2 = 'cafe\u0301'
>>> s1, s2
('café', 'café')
>>> len(s1), len(s2)
(4, 5)
>>> s1 == s2
False

U+0301 是 COMBINING ACUTE ACCENT，加在“e”后面得到“é”。在 Unicode 标准中，'é' 和 'e\u0301' 这样的序列叫“标准等价物”（canonical equivalent），应用程序应该把它们视作相同的字符。但是，Python 看到的是不同的码位序列，因此判定二者不相等。

这个问题的解决方案是使用 unicodedata.normalize 函数提供的 Unicode 规范化。这个函数的第一个参数是这 4 个字符串中的一个：'NFC'、'NFD'、'NFKC' 和 'NFKD'。

1. NFC：使用最少码位构成等价字符串
2. NFD：将所有的组合字符解析为基字符和单独的组合字符
3. NFKC：基本上就是 NFC 的兼容模式，添加了对兼容字符的处理
4. NFKD：基本上就是 NFD 的兼容模式，添加了对兼容字符的处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

>>> from unicodedata import normalize
>>> s1 = 'café'  # 把"e"和重音符组合在一起
>>> s2 = 'cafe\u0301'  # 分解成"e"和重音符
>>> len(s1), len(s2)
(4, 5)
>>> len(normalize('NFC', s1)), len(normalize('NFC', s2))
(4, 4)
>>> len(normalize('NFD', s1)), len(normalize('NFD', s2))
(5, 5)
>>> normalize('NFC', s1) == normalize('NFC', s2)
True
>>> normalize('NFD', s1) == normalize('NFD', s2)
True

保存文本之前，最好使用 normalize('NFC', user_text) 清洗字符串。NFC 也是 W3C 的 “Character Model for the World Wide Web: String Matching and Searching” 规范推荐的规范化形式。

使用 NFC 时，有些单字符会被规范成另一个单字符。例如，电阻的单位欧姆（Ω）会被规范成希腊字母大写的欧米加。这两个字符在视觉上是一样的，但是比较时并不相等，因此要规范化，防止出现意外：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

>>> from unicodedata import normalize, name
>>> ohm = '\u2126'
>>> name(ohm)
'OHM SIGN'
>>> ohm_c = normalize('NFC', ohm)
>>> name(ohm_c)
'GREEK CAPITAL LETTER OMEGA'
>>> ohm == ohm_c
False
>>> normalize('NFC', ohm) == normalize('NFC', ohm_c)
True

下面是 NFKC 的具体应用：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

>>> from unicodedata import normalize, name
>>> half = '½'
>>> normalize('NFKC', half)
'1⁄2'
>>> four_squared = '4²'
>>> normalize('NFKC', four_squared)
'42'
>>> micro = 'μ'
>>> micro_kc = normalize('NFKC', micro)
>>> micro, micro_kc
('μ', 'μ')
>>> ord(micro), ord(micro_kc)
(181, 956)
>>> name(micro), name(micro_kc)
('MICRO SIGN', 'GREEK SMALL LETTER MU')

使用 '1/2' 替代 '½' 可以接受，微符号也确实是小写的希腊字母 'µ'，但是把 '4²' 转换成 '42' 就改变原意了。某些应用程序可以把 '4²' 保存为 '4<sup>2</sup>'，但是 normalize 函数对格式一无所知。

因此，NFKC 或 NFKD 可能会损失或曲解信息，但是可以使用 NFKC 和 NFKD 规范化形式时要小心，而且只能在特殊情况中使用，例如搜索和索引，而不能用于持久存储，因为这两种转换会导致数据损失。：用户搜索 '1 / 2 inch' 时，如果还能找到包含 '½ inch' 的文档，那么用户会感到满意。

使用 NFKC 和 NFKD 规范化形式时要小心，而且只能在特殊情况中使用，例如搜索和索引，而不能用于持久存储，因为这两种转换会导致数据损失。

大小写折叠

除了组合字符以及兼容字符外，字母的大小写也是一些语言中非常重要的处理对象。对此，显然最常见的方法是 str.lower()，此外，还有 str.casefold()，即大小写折叠。

这两个函数对绝大多数字符来说是等价的，但是对于极少数的特殊字符会得到不同的结果（自 Python3.4 起，有 116 个字符的处理结果不一致）

这是一个规范化字符串匹配函数的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

"""
Utility functions for normalized Unicode string comparison.

Using Normal Form C, case sensitive:

    >>> s1 = 'café'
    >>> s2 = 'cafe\u0301'
    >>> s1 == s2
    False
    >>> nfc_equal(s1, s2)
    True
    >>> nfc_equal('A', 'a')
    False

Using Normal Form C with case folding:

    >>> s3 = 'Straße'
    >>> s4 = 'strasse'
    >>> s3 == s4
    False
    >>> nfc_equal(s3, s4)
    False
    >>> fold_equal(s3, s4)
    True
    >>> fold_equal(s1, s2)
    True
    >>> fold_equal('A', 'a')
    True

"""

from unicodedata import normalize

def nfc_equal(str1, str2):
    return normalize('NFC', str1) == normalize('NFC', str2)

def fold_equal(str1, str2):
    return (normalize('NFC', str1).casefold() ==
            normalize('NFC', str2).casefold())

除了 Unicode 规范化和大小写折叠（二者都是 Unicode 标准的一部分）之外，有时需要进行更为深入的转换，例如把 'café' 变成 'cafe'。下一节说明何时以及如何进行这种转换。

极端“规范化”：去掉变音符号

去掉变音符号不是正确的规范化方式，因为这往往会改变词的意思，而且可能误判搜索结果，但是在搜索领域往往需要这么做。

除了搜索，去掉变音符号还能让 URL 更易于阅读，至少对拉丁语系语言是如此。下面是维基百科中介绍圣保罗市（São Paulo）的文章的 URL：

1

http://en.wikipedia.org/wiki/S%C3%A3o_Paulo

其中，“%C3%A3” 是 UTF-8 编码 “ã” 字母（带有波形符的 “a”）转义后得到的结果。下述形式更友好，尽管拼写是错误的：

1

http://en.wikipedia.org/wiki/Sao_Paulo

这里提供一个去除变音符号的算法。具体而言，首先将所有的组合字符解析为基字符和组合字符（NFD 格式），然后滤除所有的组合字符，最后进行重组即可（NFC 格式）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import unicodedata
import string


def shave_marks(txt):
    """去掉全部变音符号"""
    norm_txt = unicodedata.normalize('NFD', txt)  
    shaved = ''.join(c for c in norm_txt
                     if not unicodedata.combining(c))  
    return unicodedata.normalize('NFC', shaved)

----------------------------------------------------------------------------
>>> order = '“Herr Voß: • ½ cup of OEtker™ caffè latte • bowl of açaí.”'
>>> shave_marks(order)
'“Herr Voß: • ½ cup of OEtker™ caffe latte • bowl of acai.”'  ➊
>>> Greek = 'Zέφupoς, Zéfiro'
>>> shave_marks(Greek)
'Ζεφupoς, Zefiro'  ➋

更进一步地，只把拉丁基字符中所有的变音符号删除

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

def shave_marks_latin(txt):
    """把拉丁基字符中所有的变音符号删除"""
    norm_txt = unicodedata.normalize('NFD', txt)  
    latin_base = False
    keepers = []
    for c in norm_txt:
        if unicodedata.combining(c) and latin_base:  # 基字符为拉丁字母时，跳过组合记号
            continue  # 忽略拉丁基字符上的变音符号
        keepers.append(c)                            
        # 如果不是组合字符，那就是新的基字符
        if not unicodedata.combining(c):             # 检测新的基字符，判断是不是拉丁字母
            latin_base = c in string.ascii_letters
    shaved = ''.join(keepers)
    return unicodedata.normalize('NFC', shaved) 

一等函数

不管别人怎么说或怎么想，我从未觉得 Python 受到来自函数式语言的太多影响。我非常熟悉命令式语言，如 C 和 Algol 68，虽然我把函数定为一等对象，但是我并不把 Python 当作函数式编程语言。

——Guido van Rossum，Python 仁慈的独裁者

把函数作为对象

在 Python 中，函数是一等对象。编程语言理论家把“一等对象”定义为满足下述条件的程序实体：

• 在运行时创建
• 能赋值给变量或数据结构中的元素
• 能作为参数传给函数
• 能作为函数的返回结果

在 Python 中，整数、字符串和字典都是一等对象——没什么特别的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

>>> def factorial(n):  
...     '''returns n!'''
...     return 1 if n < 2 else n * factorial(n-1)
...
>>> factorial(42)
1405006117752879898543142606244511569936384000000000
>>> factorial.__doc__  # 这个 factorial 是 function 类的实例
'returns n!'
>>> type(factorial)  ➌
<class 'function'>

高阶函数

接受函数为参数，或者把函数作为结果返回的函数是高阶函数（higher-order function）

在函数式编程范式中，最为人熟知的高阶函数有 map、filter、reduce

map、filter 和 reduce 的现代替代品

列表推导或生成器表达式具有 map 和 filter 两个函数的功能，而且更易于阅读

1
2
3
4
5
6
7
8

>>> list(map(fact, range(6)))  ➊
[1, 1, 2, 6, 24, 120]
>>> [fact(n) for n in range(6)]  ➋
[1, 1, 2, 6, 24, 120]
>>> list(map(factorial, filter(lambda n: n % 2, range(6))))  ➌
[1, 6, 120]
>>> [factorial(n) for n in range(6) if n % 2]  ➍
[1, 6, 120]

匿名函数

为了使用高阶函数，有时创建一次性的小型函数会更便利，这便是匿名函数存在的原因。

lambda 关键字在 Python 表达式内创建匿名函数。

然而，Python 简单的句法限制了 lambda 函数的定义体只能使用纯表达式。换句话说，lambda 函数的定义体中不能赋值，也不能使用 while 和 try 等 Python 语句。

1
2
3

>>> fruits = ['strawberry', 'fig', 'apple', 'cherry', 'raspberry', 'banana']
>>> sorted(fruits, key=lambda word: word[::-1])
['banana', 'apple', 'fig', 'raspberry', 'strawberry', 'cherry']

除了作为参数传给高阶函数之外，Python 很少使用匿名函数。由于句法上的限制，非平凡的 lambda 表达式要么难以阅读，要么无法写出。

可调用对象

除了用户定义的函数，调用运算符（即 ()）还可以应用到其他对象上。如果想判断对象能否调用，可以使用内置的 callable() 函数。

1
2
3
4

>>> abs, str, 13
(<built-in function abs>, <class 'str'>, 13)
>>> [callable(obj) for obj in (abs, str, 13)]
[True, True, False]

Python 数据模型文档列出了 7 种可调用对象。

1. 自定义的函数
2. 内置函数
   • 使用 C 语言（CPython）实现的函数，如 len 或 time.strftime
3. 内置方法
   • 使用 C 语言实现的方法，如 dict.get
4. 方法
5. 类（创建实例时）
   • 调用类时会运行类的 __new__ 方法创建一个实例，然后运行 __init__ 方法，初始化实例，最后把实例返回给调用方。因为 Python 没有 new 运算符，所以调用类相当于调用函数。
6. 类的实例（要求实现 __call__ 方法）
7. 生成器函数（yield）

__call__

下面的示例实现了 BingoCage 类。这个类的实例使用任何可迭代对象构建，而且会在内部存储一个随机顺序排列的列表。调用实例会取出一个元素。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import random

class BingoCage:

	def __init__(self, items):
    	self._items = list(items) 
    	random.shuffle(self._items)  

	def pick(self):  
    	try:
        	return self._items.pop()
    	except IndexError:
        	raise LookupError('pick from empty BingoCage')  

	def __call__(self):  # bingo.pick() 的快捷方式是 bingo()
    	return self.pick()

1
2
3
4
5
6
7

>>> bingo = BingoCage(range(3))
>>> bingo.pick()
1
>>> bingo()
0
>>> callable(bingo)
True

实现 __call__ 方法的类是创建函数类对象的简便方式，此时必须在内部维护一个状态，让它在调用之间可用，例如 BingoCage 中的剩余元素。装饰器就是这样。装饰器必须是函数，而且有时要在多次调用之间“记住”某些事 （例如备忘（memoization），即缓存消耗大的计算结果，供后面使用）。

另一种对 __call__ 的解释

该方法的功能类似于在类中重载 () 运算符，使得类实例对象可以像调用普通函数那样，以 对象名() 的形式使用。

函数内省

同样的，Python 的函数也可以被视为对象。 函数有很多属性，这一特点使得函数表现得像一个对象。通过函数内省 dir() 能够得到这些属性的列表。

1
2
3
4
5
6
7
8

>>> dir(factorial)
['__annotations__', '__call__', '__class__', '__closure__', '__code__',
'__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__get__', '__getattribute__', '__globals__',
'__gt__', '__hash__', '__init__', '__kwdefaults__', '__le__', '__lt__',
'__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__',
'__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__']

其中大多数属性是 Python 对象共有的

下面的示例列出了常规对象没有而函数有的属性

1
2
3
4
5
6

>>> class C: pass  # ➊
>>> obj = C()  # ➋
>>> def func(): pass  # ➌
>>> sorted(set(dir(func)) - set(dir(obj))) # ➍
['__annotations__', '__call__', '__closure__', '__code__', '__defaults__',
'__get__', '__globals__', '__kwdefaults__', '__name__', '__qualname__']

定位参数与仅限关键字参数

两类实参：

• 位置参数 (positional)：传参时前面不带 " 变量名 ="，顺序不可变，按顺序赋给相应的局部变量.
• 关键字参数 (keyword)：传参时前面加上 " 变量名="，顺序可变，按名称赋给同名的局部变量.

Python 最好的特性之一是提供了极为灵活的参数处理机制

仅限关键字参数 (keyword-only) 是 Python 3 新增的特性，它是在 * 后面定义的参数（或在 *args 后面定义），传参时必需带变量名

下面示例中的 tag 函数用于生成 HTML 标签；使用名为 cls 的关键字参数传入 “class” 属性，这是一种变通方法，因为 “class” 是 Python 的关键字

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

def tag(name, *content, cls=None, **attrs):
    """生成一个或多个HTML标签"""
    if cls is not None:
        attrs['class'] = cls
    if attrs:
        attr_str = ''.join(' %s="%s"' % (attr, value)
                           for attr, value
                           in sorted(attrs.items()))
    else:
        attr_str = ''
    if content:
        return '\n'.join('<%s%s>%s</%s>' %
                         (name, attr_str, c, name) for c in content)
    else:
        return '<%s%s />' % (name, attr_str)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

>>> tag('br')  
'<br />'
>>> tag('p', 'hello')  
'<p>hello</p>'
>>> print(tag('p', 'hello', 'world'))
<p>hello</p>
<p>world</p>
>>> tag('p', 'hello', id=33)  
'<p id="33">hello</p>'
>>> print(tag('p', 'hello', 'world', cls='sidebar'))  
<p class="sidebar">hello</p>
<p class="sidebar">world</p>
>>> tag(content='testing', name="img")  
'<img content="testing" />'
>>> my_tag = {'name': 'img', 'title': 'Sunset Boulevard',
...           'src': 'sunset.jpg', 'cls': 'framed'}
>>> tag(**my_tag)  ➏
'<img class="framed" src="sunset.jpg" title="Sunset Boulevard" />'

在上面的示例中，cls 参数只能通过关键字参数指定，它一定不会捕获未命名的定位参数。

定义函数时若想指定仅限关键字参数，要把它们放到前面有 * 的参数后面。如果不想支持数量不定的定位参数，但是想支持仅限关键字参数，在签名中放一个 *，如下所示：

1
2
3
4
5

>>> def f(a, *, b):
...     return a, b
...
>>> f(1, b=2)
(1, 2)

获取关于参数的信息

使用内置方法

Python 的函数有大量可用于获取函数参数信息的内置方法:

• .__defaults__: 获取参数的默认值
• .__code__.co_varnames: 参数名称，包括函数中创建的临时变量
• .__code__.co_argcount: 参数总数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

def clip(text, max_len=80):
    """在max_len前面或后面的第一个空格处截断文本"""
    end = None
    if len(text) > max_len:
        space_before = text.rfind(' ', 0, max_len)
        if space_before >= 0:
            end = space_before
        else:
        space_after = text.rfind(' ', max_len)
        if space_after >= 0:
            end = space_after
	if end is None:  # 没找到空格
        end = len(text)
	return text[:end].rstrip()

1
2
3
4
5
6
7
8
9

>>> from clip import clip
>>> clip.__defaults__
(80,)
>>> clip.__code__  # doctest: +ELLIPSIS
<code object clip at 0x...>
>>> clip.__code__.co_varnames
('text', 'max_len', 'end', 'space_before', 'space_after')
>>> clip.__code__.co_argcount
2