流畅的python--2 序列构成的数组

我们把文本、列表和表格叫做数据火车。。。FOR命令通常能作用于数据火车上。      ---ABC Programmer's Handbook

不管是哪种数据结构，字符串、列表、字节序列、数组、XML元素，或是数据库查询结果，他们都共用一套丰富的操作：迭代、切片、排序、还有拼接。

1、内置序列类型概览

容器序列：list、tuple和collections.duque这些序列能存放不同类型的数据。

扁平序列：str、bytes、bytearray、memoryview和array.array这些序列只能容纳一种类型。

可变序列：list、bytearray、array.array、collections.duque和memoryview

不可变序列：tuple、str、bytes

可变序列从不可变序列那里继承了一些方法。

2、列表推导和可读性

列表推导只有一作用：生成列表。列表推导读起来更方便：

>>> symbols = "python"
>>> codes = [ord(symbol) for symbol in symbols]    # 使用列表推导读起来更方便
>>> codes
[112, 121, 116, 104, 111, 110]

其他的写法如下（不太建议）：

>>> codes = []
>>> for symbol in symbols:
...     codes.append(ord(symbol))
... 
>>> codes
[112, 121, 116, 104, 111, 110]

只用列表推导来创建新的列表，并且尽量保持简单，如果列表推导的代码超过了两行，那么就要考虑是不是要用for循环了。

python会忽略代码里的[],{}和()的换行。

列表推导不会再有变量泄露的问题：

>>> x = "my precious"
>>> dummy = [ord(x) for x in 'ABC']
>>> dummy
[65, 66, 67]
>>> x    # 在python2中x的取值会是'C'
'my precious'

列表推导可以帮助我们过滤或者加工序列中的元素，其运行速度不一定会比map/filter组合慢。

>>> symbols = "python"
>>> beyond_ascii = [ord(s) for s in symbols if ord(s) > 110]  # 这种方法不一定慢
>>> beyond_ascii
[112, 121, 116, 111]
>>> 
>>> beyond_ascii = list(filter(lambda c:c > 110, map(ord, symbols)))
>>> beyond_ascii
[112, 121, 116, 111]

生成笛卡尔积，循环的顺序调整，颜色和尺寸显示的顺序也会跟着调整。

>>> colors = ['black', 'white']
>>> sizes = ['S', 'M', 'L']
>>> tshirts = [(color, size) for color in colors for size in sizes]
>>> tshirts
[('black', 'S'), ('black', 'M'), ('black', 'L'), ('white', 'S'), ('white', 'M'), ('white', 'L')]
>>> tshirts = [(color, size) for size in sizes
...                          for color in colors]
>>> tshirts
[('black', 'S'), ('white', 'S'), ('black', 'M'), ('white', 'M'), ('black', 'L'), ('white', 'L')]

3、生成器

生成器表达式的语法跟列表推导的差不多，只不过把方括号变成了圆括号。生成器是逐个产出元素，而不是先建立一个完整的列表。

>>> colors = ['black', 'white']
>>> sizes = ['S', 'M', 'L']
>>> for tshirt in ('%s %s' % (c, s) for c in colors for s in sizes):
...     print(tshirt)
... 
black S
black M
black L
white S
white M
white L

4、元组

元组其实是对数据的记录，其每个元素都存放了记录中一个字段的数据和响应的位置。

>>> lax_coordinates = (33.9425, -118.408056)   # 洛杉矶国际机场的经纬度
>>> city, year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8014)  # 东京市的一些信息
>>> traveler_ids = [('USA', '31195855'), ('BRA', 'CE342567'),  # 一个元组列表（country_code,passport_number）
...     ('ESP', 'XDA205856')]
>>> for passport in sorted(traveler_ids):  # passport变量被绑定在每个元组上
...     print('%s/%s' % passport)   # %运算符能被匹配到对应的元组元素上
... 
BRA/CE342567
ESP/XDA205856
USA/31195855
>>> for country, _ in traveler_ids:  # for分别提取元组里的元素，也叫做拆包。因为元组中的第二个元素没有用，就赋值给'_'占位符
...     print(country)
... 
USA
BRA
ESP

 4.1 元组拆包

下面都是属于元组拆包的应用：

1、所有赋值只用一行声明就写完了：city, year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8014)

2、用%把passport元组里的元素对应到print函数的格式化字符串的空档中：('%s/%s' % passport)

 元组拆包的要求是被可迭代对象中的元素数量必须要跟接受这些元素的元素的空档数一致。另外可以用'*'来处理多余的元素。

>>> latitude, longitude = (33.9425, -118.408056)  # 元组拆包，平行赋值
>>> latitude
33.9425
>>> longitude
-118.408056
>>> a = 1
>>> b = 2
>>> b, a = a, b # 交换两个变量的值
>>> a
2
>>> b
1
>>> divmod(20, 8)
(2, 4)
>>> t = (20, 8)
>>> divmod(*t)   # 用*运算符把一个可迭代对象拆开作为函数的参数
(2, 4)

如同之前的例子所示，'_'是一个很好的占位符，另外还可以用'*'来处理剩下的元素。在python中，函数用*args来获取不确定数量的参数，这种概念被扩展到了平行赋值中。在平行赋值中，*前缀只能用在一个变量名前面，这个变量可以出现在赋值表达式的任何位置。

>>> 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))。

4.2 具名元组

collections.namedtuple是一个工厂函数，可以用来构建一个带字段名的元组和一个有名字的类--这个对调试程序有很大帮助。

>>> from collections import namedtuple
>>> #具名元组需要两个参数，一个是类名，一个是类的各字段的名字，由空格分隔开
>>> 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'

5、切片

在列表list、元组tuple、字符串str这类序列都支持切片操作。

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

• 当只有最后一个位置信息时，可以快速看出有几个元素：range(3)和my_list[:3]都返回3个元素
• 当起止位置都可见时，可以快速计算出长度，用stop-start即可
• 便于利用任意一个下表把序列分割成不重叠的两部分，只要写my_list[: x]和my_list[x: ]即可。

可以用s[a: b: c]的形式对s在a和b之间以c为间隔取值。c的值为负数意味着反向取值。

>>> s = 'bicycle'
>>> s[::3]
'bye'
>>> s[::-1]
'elcycib'
>>> s[::-2]
'eccb'

6、对序列使用+和*

+：+号两侧的序列由相同类型的数据所构成，在拼接的过程，两个被操作的序列都不会被修改。

*：把一个序列复制几份然后再拼接起来，把这个序列乘以一个整数。

+和*不会修改原来的操作对象，而是构建一个全新的序列。

>>> l = [1, 2, 3]
>>> l * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> m = ['a', 'b']
>>> l + m
[1, 2, 3, 'a', 'b']