《流畅的Python》第二部分数据结构【序列构成的数组】【字典和集合】【文本和字节序列】

第二部分数据结构

第2章序列构成的数组

内置序列类型

序列类型	序列	特点
容器序列	list、tuple、collections.deque	- 能存放不同类型的数据； - 存放的是任意类型的对象的引用
扁平序列	str、bytes、bytearray、memoryview、array.array	- 只能容纳一种类型； - 存放的是数据值； - 是一段连续的内存空间； - 只能存放字符、字节、数值等基础类型

可变序列与不可变序列

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

不可变序列：tuple、str、bytes

当改变了不可变序列的内容时，不可变序列的引用也会发生改变（对于str的修改，实质上是添加一个新的str对象，并将该对象的引用传回原实例），故效率低。他们的区别包括：

函数参数传递

def funForList(l):

    l.append(4) 		#[1, 2, 3] => [1, 2, 3, 4]

def funForStr(str):

    str = str.lower()	#"ABC" => "abc"

t_list = [1, 2, 3]

funForList(t_list)

print(t_list)			#[1, 2, 3, 4] 可变序列经过函数改变后本身发生了改变

t_str = "ABC"

funForStr(t_str)

print(t_str)			#"ABC"	不可变序列经过函数改变后本身并不会发生了改变

对象之间的传递

list_1 = []

list_2 = list_1

list_2.append(1)

print(list_1)	#list_1 原本的空序列也发生了改变

str_1 = ""

str_2 = str_1

str_2 = "abc"

print(str_1)	#str_1 没有发生改变

具体相关可以通过http://pythontutor.com/的可视化分析工具查看内部的运行流程

列表推导式

语法

[ 输出表达式循环1 循环2 .... 过滤表达式]

# 获取20以内的3的倍数

list_1 = [x for x in range(1, 20) if not x%3]

print(list_1) #[0, 3, 6, 9, 12, 15, 18]

特点

不会有变量泄露的问题，列表推导和生成器表达式，以及集合推导、字典推导等，在Python3里都有了自己的局部作用域。

生成表达式

特点

生成器表达式背后遵守了迭代器协议，可以逐个产出元素，而不是先建立一个完整的表，然后再把这个列表传递到某个构造函数里。前面的方式更能节省内存。

元组

* 运算符

拆分可迭代对象

def numberAdd(a,b):

    return a+b

print(numberAdd(*(1,2))) #将元组(1,2)拆成1,2两个单独的元素对象作为参数

# 3

元素拆包用 * 处理剩下的元素，以 * 为前缀的对象可以出现在赋值表达式的任意位置
```
a, *b, c = range(5)  #a=0	b=[1, 2, 3]	 c=4
```

具名元组

collections.namedtuple 是一个工厂函数，可以用来构建一个带字段名的元组和一个有名字的类

Student = collections.namedtuple('Student','name age gender')

stu = Student('Ming', 18, 'man')

print(stu)

# Student(name='Ming', age=18, gender='man')

多维切片和省略

省略（...）是 Ellipsis 对象的别名，Ellipsis 对象是 ellipsis 类的单一实例。
如果 x 是四维数组，x[i, ...] 就是 x[i, :, :, :] 的缩写

对序列使用 + 和 *

不修改原有操作对象，而是构建一个全新的序列。
[[] *3] *4 不等于 [[] *3 for _ in range(4)] ，前者的元素的引用指向的是同一个值
```
l1 = [[] *3] *4

l1[0].append(1)

print(l1)

# [[1], [1], [1], [1]]序列
```

序列的增量赋值

a += b，就地相加，效率高
a = a+b，先计算 a+b，然后赋值，产生了新的对象，效率较低
对不可变序列进行重复拼接操作，效率会很低（str 是一个意外，因为对字符串做 += 太普遍了，所以Cpython做了相应的优化）

一个谜题

t = (1, 2, [30, 40])

t[2] += [50, 60]

# a. t 变成(1, 2, [30, 40, 50, 60])

# b. 因为tuple不支持对它的元素赋值，所以会抛出TypeError异常

# c. 以上两个都不是

# d. a 和 b都是对的

# 正确答案 d

三个教训
- 不要把不可变对象放在元组里面
- 增量赋值不是原子操作，虽然抛出异常，但还是可能完成操作
- 查看Python的字节码对了解代码背后的运行机制很有帮助

bisect 二分查找

bisect_left(nums,target,left, right) #找到nums中第一个大于等于 target的目标位置
bisect.insort_left(nums,target,left, right) #将target 插入到该位置（搜索是O(log n), 插入却是O(n)）
bisect.bisct(nums,target,left,right) #找到nums中第一个大于 target的目标位置
bisect.bisct_right(nums,target,left,right) #同bisct
bisect.insort(nums,target,left, right) #将target 插入到该位置（搜索是O(log n), 插入却是O(n)）
bisect.insort_right(nums,target,left,right) #同bisct

数组 array

array.fromfile 从二进制文件读双精度浮点数，比从文本文件读取的速度快60倍
array.tofile 将浮点数写入二进制文件，比以每行一个浮点数的方式写入到文本文件快7倍

内存视图

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

双向队列

collections.deque 类是一个线程安全，可以快速从两端添加或者删除元素的数据类型
添加或者删除元素的操作都是原子操作，可以在多线程中安全使用，不需要担心资源锁的问题

TimSort

Timsort 是 sorted 和 list.sort 背后的排序算法

第3章字典和集合

collections.abc 模块

该模块中含有 Mapping 和 MutableMapping 抽象基类

my_dict = {}

print(isintance(my_dict, abc.Mapping))

# True

dict 映射要求映射的键是 可散列的数据类型（对象的内部状态都是不可变的，例如str，bytes，数值类型，元素全部为不可变类型的tuple）

字典推导

my_dict = {key: value for key, value in list}

当dict 中的键没有找到时：

d[k] 找不到该键时，Python会抛出异常
用 d.get(k, default) 代替 d[k]，找不到时返回默认值

setdefault

mydict.setdefault(key, []).append(new_value)

# 等同于下面，但只进行一次查询

if key not in my_dict:

	my_dict[key] = []

my_dict[key].append(new_value)

映射的弹性键查询

collections.defaultdict

设置默认的函数作为default_dactory 创建一个defaultdict

d = collections.defaultdict(lambda :None)

print(d[0])

# None

d = collections.defaultdict(list)

print(d[0])

# []

特殊方法 __ missing __

当键没有找到时，系统将调用 __ missing __ 方法，可以自定义类继承 dict 并实现 __ missing __ 方法

字典的变种

collections.OrderedDict #添加键的时候保持顺序
collections.ChainMap #可以容纳不同的映射对象，键查找时，将在不同的映射对象中之一查找直到被找到

collections.Counter #给键准备计数器

ct = collections.Counter("aabbcc")

# Counter({'a':2, 'b':2, 'c':2})

ct.update('aaazzz')

# Counter({'a':5, 'z':3, 'b':2, 'c':2})

不可变映射类型

types.MappingProxyType

给这个类添加映射，返回一个只读的映射视图，但当原映射视图有变动时，该视图也将变动，且不能直接在只读映射视图上做修改

d = {1:'A'}

d_proxy = types.MappingProxyType(d)

print(d_proxy)

# mappingproxy({1:'A'})

d[2] = 'B'

print(d_proxy)

# mappingproxy({1:'A', 2:'B'})

d_proxy[2] = 'C'

# TypeError:..........

集合

运算符	方法	描述
s & z	s. __ and __ (z)	s 和 z 的交集
s \| z	s. __ or __ (z)	s 和 z 的并集
s - z	s. __ sub __ (z)	s 和 z 的差集
s ^ z	s. __ xor __ (z)	s 和 z 的对称差集
e in s	s. __ contains __ (e)	s 是否包含元素 e
s <= z	s. __ le __ (z)	s 是否为 z 的子集
s < z	s. __ lt __ (z)	s 是否为 z 的真子集
s >= z	s. __ ge __ (z)	s 是否为 z 的父级
s > z	s. __ gt __ (z)	s 是否为 z 的真父级

dict 和 set 特点

dict 键或 set 元素必须是可散列的
字典、集合在内存上的开销巨大
dict 键或 set 元素查询很快
dict 键或 set 元素的次序取决于添加顺序
往dict 或 set 添加新键可能改变已有键的顺序

第4章文本和字节序列

字符、字节

Python3 中采用 Unicode字符标准，以及 Utf-8 编码标准
bytes 或 bytearray 对象中各个元素是介于0~255之间的整数

cafe = bytes('café',encoding='utf-8')

print(cafe)

# b'caf\xc3\xa9'

print(cafe[0])

# 99

print(cafe[:1])

# b'c'

# cafe[0] 获取的是一个整数，而cafe[:1]返回的是一个长度为1的bytes对象

结构体和内存视图

struct模块能处理bytes，bytearray和memoryview对象。

编码

在文件顶部添加一个神奇的coding注释

# coding: cp1252

解码

解码过程中可能出现三种错误

unicodedecodeerror（把二进制序列转化为字符串）
unicodeencodeerror（把字符串转化为二进制序列）
syntaxerror

处理文本文件

Unicode三明治

尽早把输入的字节序列编码成字符串
业务逻辑处理是，不能进行编码或解码
尽量晚地把字符串编码成字节序列