流畅的python笔记（二）数据结构_序列的切片操作是开区间还是闭区间-优快云博客

colors = ['black', 'white']
sizes = ['S', 'M', 'L']

tshirts = [(color, size) for color in colors
                        for size in sizes]
print(tshirts)

注意一下一个有意思的点：

列表推导式一般用来生成列表，如果要生成其它类型的序列，就需要生成器表达式出场了。

生成器表达式

用法和列表推导式几乎一模一样，只不过把中括号换成了小括号。

symbols = "acbdf"
t = tuple(ord(symbol) for symbol in symbols)
print(t)

如果生成器表达式是函数调用中的唯一参数，那么生成器表达式的小括号可以去掉，直接放在函数调用的小括号里边即可。

也可以用列表推导式来生成元组等类型，其过程是先生成一个列表，然后再将列表作为参数传递给元组类的某个构造函数。而用生成器表达式则是逐个地产出元素，而不是先建立一个完整的列表，显然生成器表达式能够更节省内存。

还是上边那个两个变量的例子，如果要打印出所有的组合，用列表推导式需要在内存中建立一个二维序列，当这个序列很大时这是不可接受的。而用生成器表达式则是一次只生成一个元素。

colors = ['black', 'white']
sizes = ['S', 'M', 'L']

for tshirt in ('%s %s' % (c, s) for c in colors
                                for s in sizes):
    print(tshirt)

三、元组

city , year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8014)
traveler_ids = [('USA', '31195855'), ('BRA', 'CE342567'), ('ESP', 'XDA205856')]
for passport in sorted(traveler_ids):
    print('%s/%s' % passport)
for country, _ in traveler_ids:
    print(country)

元组和记录

不应当只把元组当作不可变的列表，元组可以当作记录使用。这个意思是说元组中每个元素都可以看成是一个匿名的字段的值。比如上边例子中列表traveler_ids，其中每个元素都是一个元组，这个时候每个元组对象就是一条记录，记录的第一个字段是国家，第二个字段是护照号码，只不过没有明确的字段名。

元组拆包

如例子中，下边两种用法都是元组拆包，其本质就是用相同数量的变量来接收元组中的元素。

city , year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8014)
'%s/%s' % passport

本质上，可迭代对象都是可以做拆包的，比如列表：

x = ["hello", "world"]
y, z = x
print(y, z)

但是用%字符串格式化进行拆包貌似是元组专用的，至少列表是不行的。即平行赋值的拆包方式适用于任何可迭代对象，而字符串格式化只能用于元组。

一个经典用法是不借助中间变量交换两个变量的值，其本质也是元组拆包，只不过由于运算符右边只有一个元组参数，因此把小括号给省略了。

可以用 * 来将一个可迭代对象拆包作为函数的参数。divmod函数是计算商和余数，其有两个参数，分别是被除数和除数。这里用 *t 将元组t拆包用作函数的参数。

还可以将元组作为一个函数的返回值，这样就可以方便地用几个变量来接收返回值。比如os.path.split()函数就会返回以路径和最后一个文件名字符串组成的元组（path, last_part）：

拆包的时候，可能有些元素我们不感兴趣，因此可以用 _ 来作为占位符。

python中一个重要的用法是，在函数参数中用 *args 来让args列表接收不确定数量的参数。这个概念也被扩展到了平行赋值中。

平行赋值时，* 前缀只能用在一个变量名前边，但是可以出现在赋值表达式的任意位置。

嵌套元组拆包

没啥意思，看看例子。

具名元组

即collections.namedtuple，collections是python的一个标准库模块，里边存放的都是一些工厂函数，类似C++ STL中的容器或模板类。

先来个例子观察具名元组的使用：

创建一个具名元组需要两个参数，第一个是类名，第二个是一个类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是空格分隔开的字段名组成的字符串。可以通过字段名或者索引来获取一个字段的信息。

有意思的一点是，用namedtuple构建的类的实例所消耗的内存跟元组是一样的。流畅的python里的解释是字段名都被存在对应的类里边，那么问题来了，对象是怎么通过字段名来得到某个属性的值的呢？

from collections import namedtuple
import sys

Card = namedtuple("Card", "x y z")
t1 = Card(1, 2, 3)
t2 = (1, 2, 3)
print(sys.getsizeof(t1), sys.getsizeof(t2))

具名元组还有一些自己专有的属性，比如_fields类属性，_make(iterable)类方法，和实例方法_asdict()。_fields类属性是一个包含这个类所有字段名的元组。类方法_make可以接受一个可迭代对象来生成一个实例，如果不用_make的话，就只能传入很多个参数来构造，而不能直接传入一个可迭代对象。当然也可以用 * 前缀来拆包一个元组再传入构造函数。_asdict()是一个实例方法，用于将具名元组对象的信息以collections.OrderedDict的形式返回，即一个键值对列表的形式。

元组作为不可变列表

除了与增删元素有关的方法以外，元组几乎支持列表其它的所有方法。

reversed(my_tuple)并不会改变my_tuple，而是将my_tuple逆序然后返回一个新的元组。

四、切片

在python中，像列表list，元组tuple和字符串str这类序列类型都支持切片操作。

切片是左闭右开区间

切片的时候还可以选择步长，即不连续切片。

需要注意的是如果步长是负的，那么起始索引应该大于结束索引。如下图所示。

在python中对序列型对象切片的时候是使用了一个切片类的，即slice(start, stop, step)。当我们对一个序列型对象seq进行切片seq[start: stop: step]，实际上 start: stop: step 会返回一个切片对象 slice(start, stop, step)，这个时候对于切片操作，python解释器实际上会调用特殊方法__getitem__，即seq.__getitem__(slice(start, stop, step))。如下图所示，如果我们经常用某种切片，可以直接定义一个切片对象，就不用每次都输入起始点结束点和步长了。

多维切片和省略

多维切片针对的是多维数据，比如二维切片得到的就是二维数据，自然也就需要两个切片对象才行。在 [ ] 运算符里用逗号隔开两个切片对象就可以得到二维切片了，还可以用逗号隔开两个索引来得到二维索引。比如二维的numpy.ndarray可以用a[i, j]来获取某个元素，a[m : n, k : l]来得到二维切片。[ ] 运算符是与 __getitem__和__setitem__这两个特殊方法相关的。实际上我们在使用二维索引的时候，这两个特殊方法会以元组的方式来接受二维索引，即a.__getitem__((i, j))。

需要注意的是python的内置序列类型都是一维的，所以是不能用二维索引的，所以对于二维列表来说，索引方式可以是a[i][j]，但不能是a[i, j]。

python还有一个对象是省略，即三个英文句号（...）。它可以用于函数参数列表中，用于表示不确定参数数目，比如 f(a, ..., z)，也可以用于切片中，用于切片中时与具体的对象维度有关系，比如a[i, ...]，如果a是四维数组，则等价于a[i, :, :, :]，即相当于其它三个维度上都是全选的。

修改切片就地改变原序列

对于可修改序列对象来说，其切片与原序列是共享内存的，即修改切片也会修改原序列，但需要注意的是，如果要对切片赋值，那么赋值运算符右侧必须是一个可迭代对象，即使只有一个单独的值，也要转化成可迭代对象。

五、对序列使用 + 和 *

python程序员默认序列是支持 + 和 * 的操作的。 + 用来拼接两个序列，返回一个拼接后的序列。* 用来将一个序列复制几份再拼接起来。+ 和 * 都不修改原有的操作对象。

* 有一个坑（容器序列，其元素是可变对象，不能用 *，否则复制的都是同一批引用）。如下图例子，my_list是一个列表，其元素也是列表，我们知道列表是容器序列，容器序列中保存的是元素的引用，扁平序列中保存的才是数据。即序列my_list中的元素是对其它可变对象的引用。如果序列中的元素不是对可变对象的引用就没事，比如 my_list=[1, 2, 3, 4, 5, 6]。

那么怎么构建一个包含多个列表的列表呢？用列表推导式。如下图所示，原来列表推导式中用来构建列表的每一项也可以与自变量i无关。注意str是不可变序列，因此 ['_'] * 3 是合法的。

下边这种用 * 的方式是错误的。外层列表看似有三个元素，但是这三个元素都是指向同一个列表的引用。

六、序列的增量赋值 *= 与 +=

以+=为例讲解，*=类似。

+= 背后的特殊方法是 __iadd__，这个方法是用于就地加法的。但是如果一个类没有实现__iadd__方法，则python会退一步调用__add__。

a += b

对上边例子来说，如果实现了__iadd__方法，且a为可变序列，则会对a进行原地改动，即把b赋值一份接到a上，效果等价于a.extend(b)。但是如果a没有实现__iadd__，则a += b等价于 a = a + b，即计算a + b生成一个新的对象再赋值给a，这个过程b没有变，但是变量名a已经被关联到了新的对象了。

可变序列都实现了__iadd__方法，用于实现就地加法。不可变序列根本不支持这个操作，因此不会实现此方法。所以不可变对象的 += 和 *= 操作都是相当于把变量名关联到了一个新的对象。对于 *= ，其对应的方法是__imul__。

一般情况下，对不可变序列进行重复拼接操作效率很低，因为需要构造一个新对象，解释器把原来对象中的元素赋值到先得对象，然后再追加新的元素。但是str类型是个例外，因为字符串 +=操作太普遍了，因此CPython对其进行了优化，为str对象初始化内存的时候，会留出额外的可扩展空间，因此增量操作的时候，不会涉及复制原有字符串到新位置这类操作。

接下来看一个额外例子，能否改变元组中的可变对象？

如上例子所示，可以看到，元组中有可变对象列表，对列表的改动成功了，但是也抛出了异常。这给了我们一个教训，即不要在元组中放置可变对象。

七、list.sort方法与内置函数sorted

对于序列对象而言，排序是很重要的内容。

list.sort会就地排序列表，返回值是None，这也是python的一个惯例，对于就地操作的方法返回None，比如random.shuffle也是这样。

内置函数sorted则会返回一个列表，其接受任何形式的可迭代对象作为参数，但不管接受的是什么参数，其返回值都是列表。

list.sort和sorted都有两个可选的参数。一个是reverse，如果设置为True，则会降序排列。还有一个可选参数key，这个参数是一个只接受一个参数的函数，其会对序列中的每一个元素进行操作（不改变原始序列中的值），产生结果是排序算法依赖的对比关键字。比如说 key=str.lower，将序列中每个字符都小写化，可以在排序的时候忽略大小写，或者key=len，则会基于字符串长度排序。key的默认值是恒等函数，即默认用元素自己的值来排序。

八、用bisect模块管理已排序的序列

bisect模块主要包含两个函数，bisect和insort，两个函数都利用二分查找算法来在有序序列中查找或插入元素。

用bisect搜索

用法为：position = bisect.bisect(haystack, needle)

其中haystack是一个排序好的序列，needle是待查找的值，返回值position是一个索引值，在索引position之前的索引处数字都是小于needle处的值的，比如下边例子，needle = 3，则position = 1，若needle = 4，则position = 2。

import bisect
haystack = [1, 4, 5, 6, 8, 12, 15, 20]
needle = 4

position = bisect.bisect(haystack, needle)
print(position)

bisect有两个可选参数用于选定搜索的范围。lo和hi，lo默认是0，hi默认是序列的长度。

bisect函数其实是bisect_right的别名，还有一个姊妹函数bisect_left。bisect_right返回的位置处是第一个大于needle的索引，bisect_left返回的是第一个小于等于needle的值所在的索引。比如下边例子，bisect_right返回3，bisect_left则返回1。

haystack = [1, 4, 4, 5, 6, 8, 12, 15, 20]
needle = 4

用bisect.insort插入新元素

用法：insort(seq, item)

seq是排好序的有序序列，item是我们要插入的元素，用insort可以把变量item插入到序列seq中，并保持seq有序。insort相当于先查找再插入，即等价于先用bisect再用insert之类的插入。

insort跟bisect一样，有lo和hi两个可选参数控制查找范围，也有个变体insort_left，此变体背后使用bisect_left，即在左边插入，insort则是在右边插入。

九、替换列表的数据结构

有时候列表不是最优选。比如要存放1000万个浮点数，数组（array）的效率要高很多，因为数组背后存放的不是float对象，而是数字的机器翻译，即字节表述。再比如，若要对序列频繁进行先入先出，deque(双端队列)的速度应该更快。

数组

这里指的是python标准库中的数组，即array.array。而不是numpy数组。

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

创建数组需要一个类型码，类型码用来表示再底层的C语言应该存放怎样的数据类型。比如array('b')创建出的数组就只能存放一个字节大小的整数，‘b’代表有符号的字符，大小范围为 -128 到 127。这样指向以后，数组中就不能存放其它类型的数据。

例题：创建一个1000万个浮点数的数组，把数组保存文件里，再从文件读取此数组。

from array import array
from random import random

floats = array('d', (random() for i in range(10**2))) # 生成器表达式可以用于生成任意序列类型，'d'表示是双精度浮点数对象，跟python内置类型不同，array.array是需要指定数值精度的
print(floats[-1]) # 查看数组中最后一个元素
fp = open('floats.bin', 'wb') # 以二进制可写的方式打开一个文件，如果文件不存在，则创建该文件
floats.tofile(fp) # 用.tofile方法把数组中的内容写入到二进制文件floats.bin中
fp.close() # 关闭文件
floats2 = array('d') # 再创建一个存储双精度浮点数的数组对象
fp = open('floats.bin', 'rb') # 打开上边关闭的文件
floats2.fromfile(fp, 10**2) # 用.fromfile方法从打开的文件中读取10**2个元素到新建的数组
fp.close() # 关闭文件
print(floats2[-1]) # 查看第二个数组的最后一个元素
print(floats2 == floats) # 判断两个数组是否相等

从以上例子可以看出，用python数组array.array是能够很方便地与文件进行交互的，通过tofile方法将数组内容存储到文件，再通过fromfile方法将文件中内容读取到数组。上边我们把浮点数写入读出二进制文件都要比文本文件快很多倍。而且二进制文件的大小也要更小一点。除了用array.array的tofile和fromfile方法外，还可以用pickle模块的dump方法将对象存储到文件，或者load方法从文件中加载信息到某个对象。pickle是python专用的，其文件后缀一般是 .pkl，可以选择是保存成文本文件或二进制文件。

python中的array.array非常类似C中的数组，也是要提供数据类型。需要注意的是array数组不支持list.sort这种原地排序方法，要给array数组排序的话只能先用sorted生成一个排序好的新数组，再让原数组名关联此新数组。对于查找和插入则仍然可以使用bisect模块来完成。

内存视图

memoryview是一个内置类，能让用户在不复制内容的情况下操作同一个数组的不同切片，本质上其实跟torch中的view方法思想有类似之处，就是从不同的角度看待同一块内存区域的数据。

from array import array
from random import random

numbers = array('h', [i for i in range(-2, 3)]) # 列表推导式生成数组，数组元素是十六进制整数
memv = memoryview(numbers) # 从内存角度看待该数组
print(len(memv), memv.tolist()) # 打印出数组长度于具体值，可以看出跟number一样
print(memv[0]) # 数组的第一个元素就是现在内存视图的第一个元素
memv_oct = memv.cast('B') # memv.cast类型强制转换，改成以无符号字符的角度来看待numbers数组的那一块内存
print(len(memv_oct), memv_oct.tolist()) # 因为一个无符号字符占八个字节，原先十六进制中的一个数字被拆分成了两个，因此内存视图长度加倍
memv_oct[5] = 4 # 改变内存视图的某个索引的值，可以影响到原数组，因为是共享内存的。
print(numbers)