内置序列类型概览

列表推导和生成器表达式

In [20]: {s for s in "sstringg"}  # 集合推导
Out[20]: {\'g\', \'i\', \'n\', \'r\', \'s\', \'t\'}

In [25]: [s for s in "string" if s != "i"]
Out[25]: [\'s\', \'t\', \'r\', \'n\', \'g\']

In [27]: {s:i for i, s in enumerate("string")}
Out[27]: {\'g\': 5, \'i\': 3, \'n\': 4, \'r\': 2, \'s\': 0, \'t\': 1}

In [28]: (s for s in "string" if s != "i")
Out[28]: <generator object <genexpr> at 0x7fd844195fc0>

In [29]: list(s for s in "string" if s != "i")  # 这里只需要一个括号
Out[29]: [\'s\', \'t\', \'r\', \'n\', \'g\']

元组

元组拆包

In [30]: a, b, *rest = range(5)

In [31]: a, b, *rest  # rest均是一个list，无论有没有值
Out[31]: (0, 1, 2, 3, 4)

In [32]: a, b, *rest = range(3)

In [33]: a, b, *rest
Out[33]: (0, 1, 2)

In [34]: rest
Out[34]: [2]

In [35]: a, b, *rest = range(2)

In [36]: rest
Out[36]: []

具名元组

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

In [1]: from collections import namedtuple

In [2]: City = namedtuple(\'City\', \'name coutry population coordinates\')

In [3]: tokyo = City(\'Tokyo\', \'JP\', 36.933, (35.689722, 139.691667))

In [4]: tokyo.name  # 可以通过属性，以及索引来获取值．
Out[4]: \'Tokyo\'

In [5]: tokyo["name"]
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-5-b68fdbfa4b27> in <module>()
----> 1 tokyo["name"]

TypeError: tuple indices must be integers or slices, not str

In [6]: tokyo[1]
Out[6]: \'JP\'

In [7]: City._fields　# 包含这个类所有字段名称的元组
Out[7]: (\'name\', \'coutry\', \'population\', \'coordinates\')

In [8]: LatLong = namedtuple(\'LatLong\', \'lat long\')

In [9]: City = namedtuple(\'City\', \'name coutry population coordinates\')

In [10]: delhi_data = (\'Delhi NCR\', \'IN\', 21.935, LatLong(28.613889, 77.208889))

In [11]: delhi = City._make(delhi_data)  # 接受一个可迭代对象来生成这个类的一个实例,等于City(*delhi_data)

In [12]: delhi._asdict()  # 具名元组以 collections.OrderedDict 的形式返回
Out[12]: 
OrderedDict([(\'name\', \'Delhi NCR\'),
             (\'coutry\', \'IN\'),
             (\'population\', 21.935),
             (\'coordinates\', LatLong(lat=28.613889, long=77.208889))])

In [13]: for key, value in delhi._asdict().items():
    ...:     print(key + \':\', value)
    ...:     
name: Delhi NCR
coutry: IN
population: 21.935
coordinates: LatLong(lat=28.613889, long=77.208889)

对序列使用+和*

In [14]: board = [[\'_\'] * 3 for i in range(3)]

In [15]: board
Out[15]: [[\'_\', \'_\', \'_\'], [\'_\', \'_\', \'_\'], [\'_\', \'_\', \'_\']]

In [16]: board[1][2]
Out[16]: \'_\'

In [17]: board[1][2] = \'X\'

In [18]: board
Out[18]: [[\'_\', \'_\', \'_\'], [\'_\', \'_\', \'X\'], [\'_\', \'_\', \'_\']]

上面的代码等价于：

In [23]: def f():
    ...:     board = []
    ...:     for i in range(3):
    ...:         row = [\'_\'] * 3
    ...:         board.append(row)

而下面的代码会出现预想不到的结果：

In [19]: weird_board = [[\'_\'] * 3] * 3

In [20]: weird_board
Out[20]: [[\'_\', \'_\', \'_\'], [\'_\', \'_\', \'_\'], [\'_\', \'_\', \'_\']]

In [21]: weird_board[1][2] = \'X\'

In [22]: weird_board
Out[22]: [[\'_\', \'_\', \'X\'], [\'_\', \'_\', \'X\'], [\'_\', \'_\', \'X\']]

等价于：

row=[\'_\'] * 3
board = []
for i in range(3):
    board.append(row)

序列的增量赋值

变量名会不会被关联到新的对象，完全取决于这个类型有没有实现 __iadd__ 这个方法.

什么意思？对于

a += b

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

对于元组里的可变列表进行+=操作

In [25]: t = (1, 2, [30, 40])

In [26]: t[2] += [50, 60]
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-26-d877fb0e9d36> in <module>()
----> 1 t[2] += [50, 60]

TypeError: \'tuple\' object does not support item assignment

In [27]: t
Out[27]: (1, 2, [30, 40, 50, 60])

得到的结论是：

• 会改变
• 并且会抛出异常
• 增量赋值不是一个原子操作

list.sort方法和内置函数sorted

• list.sort 方法会就地排序列表，也就是说不会把原列表复制一份。这也是这个方法的返回值是 None 的原因，提醒你本方法不会新建一个列表。
• list.sort 相反的是内置函数 sorted，它会新建一个列表作为返回值。

两个可选的关键字参数

• reverse, True or False, default=False
• key, 对比关键字.key=str.lower 来实现忽略大小写的排序，或者是用 key=len 进行基于字符串长度的排序。

用bisect来管理已排序的序列

利用二分查找算法来在有序序列中查找或插入元素

import bisect
bisect.bisect(list, val)

bisect 函数其实是 bisect_right 函数的别名，后者还有个姊妹函数叫bisect_left。它们的区别在于， bisect_left 返回的插入位置是原序列中跟被插入元素相等的元素的位置，也就是新元素会被放置于它相等的元素的前面，而 bisect_right返回的则是跟它相等的元素之后的位置。

bisect.insort(seq, item) 把变量 item 插入到序列 seq 中

当列表不是首选时

array

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

内存视图

memoryview 是一个内置类，它能让用户在不复制内容的情况下操作同一个数组的不同切片。 这个功能在处理大型数据集合的时候非常重要。

>>> numbers = array.array(\'h\', [-2, -1, 0, 1, 2])
>>> memv = memoryview(numbers) ➊
>>> len(memv)
5
>>> memv[0] ➋
-2
>>> memv_oct = memv.cast(\'B\') ➌
>>> memv_oct.tolist() ➍
[254, 255, 255, 255, 0, 0, 1, 0, 2, 0]
>>> memv_oct[5] = 4 ➎
>>> numbers
array(\'h\', [-2, -1, 1024, 1, 2]) 

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

但是删除列表的第一个元素（抑或是在第一个元素之前添加一个元素）之类的操作是很耗时的，因为这些操作会牵扯到移动列表里的所有元素。
collections.deque 类（双向队列）是一个线程安全、可以快速从两端添加或者删除元素的数据类型。

>>> from collections import deque
>>> dq = deque(range(10), maxlen=10) ➊
>>> dq
deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
>>> 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)
>>> dq.appendleft(-1) ➌
>>> dq
deque([-1, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
>>> dq.extend([11, 22, 33]) ➍
>>> dq
deque([3, 4, 5, 6, 7, 8, 9, 11, 22, 33], maxlen=10)
>>> dq.extendleft([10, 20, 30, 40]) ➎
>>> dq
deque([40, 30, 20, 10, 3, 4, 5, 6, 7, 8], maxlen=10)

其他的队列有空在总结．