序列分类

1.按存放的数据类型分类：

容器类型（能存放不同类型的数据）:list、tuple、coolections.deque

扁平序列（只能存放一种类型的数据）:str、bytes、bytearray、memoryview、array.array

容器类型存放它们所包含的任意类型的对象的引用，而扁平类型存放的是值而不是引用。(扁平序列是一段连续的存储空间)

2.按能否被修改分类：

可变序列：list、bytearray、array.array、coolections.deque、memoryview

不可变序列：tuple、str、bytes

可变类型继承了不可变类型的一些方法，拓展了一些其他方法。

列表推导式和生成器表达式

列表推导式可以方便的把一个序列或其他可迭代类型中的元素过滤或加工，构建一个新列表。

symbols = 'acdghlz'
codes = []
for symbol in symbols:
codes.append(ord(symbol))
print(codes)

symbols = 'acdghlz'
codes = [ord(symbol) for symbol in symbols]
print(codes)

上述两段代码都可以将字符串变为Unicode码位，但相比于普通for循环而言列表推导式显得更简洁明了。而列表推导式只能用于生成列表，生成其他类型的序列就需要用到生成器表达式。

生成器表达式优点：生成器表达式背后遵守迭代器协议，逐个抛出元素，而不是事先建立一个完整列表再把列表传到某个构造函数中。显然生成器表达式更节省内存。

symbols = 'acdghlz'
codes_t = tuple(ord(symbol) for symbol in symbols)　　//构造一个元组
codes_l = list(ord(symbol) for symbol in symbols)　　//构造一个列表
print(codes_t)
print(codes_l)

colors = ['black', 'white']
sizes = ['S','M','L']
for tshirt in ('%s %s' % (c,s) for c in colors for s in sizes):　　//实现笛卡儿积，逐个产生元素
print(tshirt)

元组拆包

1.元组拆包默认平行赋值：即把一个可迭代的对象里的元素一并赋值给对应的变量组成的元组中：

x_y = (60,100)
x,y = x_y
print(x,y)　　　　//结果为：60 100

2.可以用*运算符把一个可迭代对象拆开作为函数参数：

print(divmod(20,8))
t = (20,8)
print(divmod(*t))
a, b = divmod(*t)
print((a,b))　　//打印结果均为（2，4）

3.元组拆包时若不是对所有元素感兴趣，可使用占位符 _ 处理。

4.用*处理剩下的元素，*前缀只能用在一个变量名前，但这个变量可以出现在表达式的任意位置

a, *body, c, d = (range(7))
print((a, body, c, d))
*head, b, c, d = (range(7))
print((head, b, c, d))
//结果如下：
(0, [1, 2, 3, 4], 5, 6)
([0, 1, 2, 3], 4, 5, 6)

5.具名元组

collections.namedtuple是一个工厂函数，它可以用来构建一个带字段名的元组和一个具有名字的类。具有普通元组的属性和一些专有属性。

切片

list[起始位置：结束位置：步长]，三个参数均可为负数。

>>> l=[10,20,30,40,50,60]

l[:2]
[10, 20]
l[2:]
[30, 40, 50, 60]
l[::2]
[10, 30, 50]

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

>>> l = list(range(10))

l[2:5] = 100　　//报错
Traceback (most recent call last):
File "", line 1, in
l[2:5] = 100
TypeError: can only assign an iterable
l[2:5] = [100]　　//结果正常
l
[0, 1, 100, 5, 6, 7, 8, 9]

list.sort和内置函数sorted

sort原地排序，即改变原对象，返回None；sorted创建一个新对象作为返回值，sorted可以接受任何可迭代对象作为参数，返回一个列表。

关键字参数reverse和key

reverse:默认为false，升序;改为true则为降序排列。

key:一个只用一个参数的函数，该函数用于序列中每一个元素，产生的结果作为排序算法依赖的对比关键字。

>>> fruits = ['grade','raspberry','apple','banana']

sorted(fruits)
['apple', 'banana', 'grade', 'raspberry']　　//升序
sorted(fruits,reverse=True)
['raspberry', 'grade', 'banana', 'apple']　　//降序排
sorted(fruits,key=len)
['grade', 'apple', 'banana', 'raspberry']　　//按长度排
sorted(fruits,key=len,reverse=True)
['raspberry', 'banana', 'grade', 'apple']　　//按长度降序
fruits
['grade', 'raspberry', 'apple', 'banana']　　//原对象不变
fruits.sort()　　　　　　　　　　　　　　　　//返回空
fruits
['apple', 'banana', 'grade', 'raspberry']　　//改变原对象

还可用bisect模块中的bisect和insort函数来在有序序列中查找或插入元素（基于二分查找算法）。

某些情况列表不是最好的选择

列表虽然既灵活有简单，但面对各种需求可能有更好的选择。

1.只需要一个只包含数字的列表，那么array.array比list高效。（数组支持所有跟可变序列有关的操作）

还提供了.frombytes和.tofile等更快读写文件的方法。参数为文件对象。

2.内存视图，memoryview是一个内置类，他能在让用户不复制内容的情况下操作同一个数组的不同切片。memoryview.cast概念跟数组模块相似，能用不同方式读写同一块内存数据，且内容字节不会随意变动。如下，用memoryview精准修改了数组某个字节：

>>> import array

numbers = array.array('h',[-2,-1,0,1,2]) //利用一个短整型有符号数(类型吗h)数组创建一个memoryview
memv = memoryview(numbers)
len(memv)
5
memv[0]
-2
memv_oct = memv.cast('B') //将memoryview内容改为'B'类型，无符号字符
memv_oct.tolist()
[254, 255, 255, 255, 0, 0, 1, 0, 2, 0]
memv_oct[5] = 4 //把位置5的字节赋值成4
numbers
array('h', [-2, -1, 1024, 1, 2]) //第三个数高位字节改成4，故0变为1024

3.Numpy和Scipy，优秀的科学计算库。处理大量数据时必备。

4.双端队列及其他队列。

collections.deque类可以快速从两端添加或删除元素的数据类型。

queue提供了同步(线程安全)类Queue,LifoQueue,PriorityQueue,不同线程可以用这些数据类型交换信息。三个类构造方法有一个可选参数maxsize，它接受正整数作为输入值，用来限定队列大小。满员时，类不会扔掉旧的元素来腾出位置(相反，deque会扔掉旧元素插入新元素)，它会锁住，直到另外的线程移除了某个元素腾出了位置。

还有multiprocessing包(用于进程间通信)，asyncio包(类似queue包，但多了JoinableQueue为异步编程里的任务管理提供了专门的便利)，heapq包等。

以上内容来自《流畅的python》第二章