流畅的python笔记

鸭子类型协议不完全总结
序列：len，getitem
切片：getitem
v[0]分量的取值和写值：getitem和setitem
v.x属性的取值和写值：getattr和setattr
迭代：1）iter，2）getitem
上下文管理器：enter，exit
+=：1）iadd，2）add
可散列：hash，eq
in测试：1）contains，2）iter，3）getitem

第一章，python数据模型
__repr__得到对象的字符串表现形式
if obj，实际执行的是bool(obj)，python解释器调用obj.__bool__，如果没有__bool__，会调用__len__看是否为0
len(obj)，python解释器调用obj.__len__()
obj[key]，python解释器调用obj.__getitem__(key)
'hello world %s' % x， 'hello world %r' % x ，对于x=123两者输出都一样，x='abc'前者输出hello world abc，后者输出hellow world 'abc'

第二章，序列构成的数组
容器序列：引用，list、tuple、collections.deque
扁平序列：值，str、bytes、array.array
可变序列：list、array.array
不可变序列：tuple、str
*args ：序列中的值
args：序列
列表推导不再会有变量泄漏的问题
元组拆包：_，a, b, *args = [1, 2, 3, 4, 5, 6]，不要的可以用_或者*args
切片实际操作步骤：首先生成切片对象slice(a, b, c)，再使用__getitem__方法取值
序列使用 + 和 * 时，原序列都不会被修改，而是新建序列
创建3个空列表：应该使用[[] for i in range(3)]，而不是使用[[]] * 3
array.array：浮点数效率高
set：in测试效率高

第三章，字典和集合
用户自定义类型的对象都是可散列的，散列值就是id()返回的值
dict.get(k, w)：查找key时，设置默认
dict.setdefault(k, w)：更新key时，设置默认
defaultdict(type)：可以设置字典value的缺省类型，例如list
__missing__：找不到key时会调用__missing__特殊方法
集合没有getitem，但是有iter

第四章，文本和字节序列
待补充

第五章，一等函数
函数本质上就是定义了__call__的类，此外还有些函数特有的属性，例如__kwdefaults__，__defaults__，__get__等等
建议用生成器表达式取代map，filter
匿名函数lambda，主要适用于传参，可以省略函数名
operator：提供了一些算数运算符函数，例如相乘mul
functools.partial(func, arg)：用于冻结参数，func是可调用对象，arg是冻结的参数

第六章，使用一等函数实现设计模式
用类实现策略模式：用类实现具体策略，相同部分作为基类，不同部分作为子类
用函数实现策略模式：用函数实现具体的策略，函数作为参数传递给类的实例

第七章，函数装饰器和闭包
自由变量：未在本地作用域中绑定的变量，可以被内部嵌套函数访问，并能保留下来的
nonlocal：声明变量为自由变量
基本装饰器（2层嵌套）：必须return2次，如果只return wrapper，则被装饰函数有返回值时会永远返回None
参数化装饰器（3层嵌套）：支持装饰器传参

基本装饰器代码实现：

def clock(fn):
    @functools.wraps()
    def wrapper(*arg, **kwargs):
        ret = fn(*arg, **kwargs)
        return ret
    return wrapper    

第八章，对象引用、可变性和垃圾回收
变量是标注，不是盒子：引用式变量（例如列表、字典）可以同时有多个不同的变量名
引用性变量的不同变量名，值/id都是相等的
python的'=='：只判断值是否相等，id可以不等。有点类似js的'==='
可以用is判断id是否相同，不必使用id()函数
元组的不可变性：保存的引用不可变，但是引用的对象可以变
创建别名：b = lista
浅复制：b = lista[:]，b = lista.copy()，b= copy.copy(lista)
深复制：b= copy.deepcopy(lista)
如果lista列表内部有“可变的引用对象”(例如字典、集合、列表，元组算不可变的引用对象)，发生改变时，会影响到浅拷贝，但不会影响到深拷贝。
防御可变参数：函数传参时，可变参数的默认值必须使用None。如果使用可变参数作为默认值，则不传参时，多个函数调用方会共享同一个可变参数。
python是按引用传参的，对参数修改后：1）不可变参数会重新开辟内存，实质相当于传统的按值传参；2）可变参数会就地修改，实质相当于传统的按引用传参。

第九章，符合python风格的对象
尽早捕获错误：如果涉及到参数转换，在__init__中完成可以尽早捕获错误
classmethod：静态函数，第一个参数是类，可以调用类属性/类方法
staticmethod：静态函数，没有特殊参数，本质上就是放在类中的全局函数
格式化：format
私有属性：__x可以通过“object_classname__x”来访问，所以本质上单下划线和双下划线没什么区别
属性设置为只读：私有属性 + @property
__slots__属性：节省空间，使用后无法新增属性

第十章，序列的修改、散片和切片
获取类的引用方法：type(self)，self.__class__，被@classmethod装饰的函数的第一个参数。要访问类变量，必须先获取类的引用。
实现了一个多维向量类（序列）：
　　v1：兼容2d，一些基本的序列方法
　　v2：实现getitem，支持分量访问、切片访问。没有实现setitem，所以不支持分量设值、切片设值。
　　v3：实现getattr和setattr，支持属性访问，setattr必须同时实现，否则对属性进行设值后(v.x)会与分量值(v[0])产生冲突
　　v4：实现eq和hash，可散列
　　v5：格式化

第十一章，从协议到抽象基类
鸭子类型：协议是非正式的接口
白鹅类型：使用抽象基类正式明确接口
abc：自定义抽象基类，抽象方法
collections.abc：提供一些内置的抽象基类
numbers：抽象基类数字塔。包括Number，Complex，Real，Rational，Intergral。
抽象基类（abc.ABC）：抽象基类必须继承abc.ABC，才能约束子类必须实现抽象方法，抽象基类不能被实例化
抽象方法（@abc.abstractmethod）：抽象基类的抽象方法，不用实现，子类继承抽象基类时必须实现抽象方法，才能被实例化
抽象基类主要作用：作为超类；isinstance检查；注册（xx.register）；自动识别（不用注册或继承也能通过isinstance检查）
isinstance检查举例：collections.abc.Sequence抽象基类包含的方法有__contains__，__iter__，__len__，__getitem__，__reversed__，index，count，其中抽象方法是__len__，__getitem__。如果某对象想通过isinstance(obj, collections.abc.Sequence)检查，方法一是继承Sequence并实现2个抽象方法，方法二是自己实现所有的方法，并注册Sequence.register。
猴子补丁：直接给类（注意不是类的实例）添加新的方法。这样可以在运行时修改类或模块，而不改动源码。
python是动态强类型语言：动态指运行时检查类型，强类型指很少隐式转换类型。

第十二章，继承的优缺点
内置类型字典更新值的方法：
DoppeDict(one=1)：调用__init__()
DoppeDict['two'] = 2：设置时调用__setitem__()，获取时调用__getitem__()
DoppeDict.update('three', 3)：调用update()，
子类化内置类型时，不会调用用户定义的类覆盖的特殊方法
多重继承：广度优先，深度优先，python3是广度优先
委托给父类执行：super().func()，多重继承时可以指定由哪个父类执行xx.func()
继承UserDict, UserList, UseString：速度慢，以扩展
继承Dict, List, String：速度快，难扩展

第十三章，正确重载运算符
一元: -neg，+pos，~invert
算术: +add，
比较: ==eq，!=ne
增量赋值: +=iadd
运算时，先正向，后反向，比较运算还会比较id，通过返回NotImplemented切换
python3.5新引入@做点积运算

第十四章，可迭代的对象、迭代器和生成器
iterable具有可调用的iterator，可以通过iter(iterable)从iterable中获得iterator。
iterator的实现方法：1）iter + next，其中iter方法中return self，next方法中逐个返回值。2）iter，iter方法中使用yield生成器返回值。
generator属于iterator。
Sequence实现了getitem和len特殊方法就可以被迭代，因为解释器在尝试迭代对象x时，会执行如下步骤：1）调用iter(x)；2）没有iter就调用getitem；
StopIteration表示迭代器到头。
典型的迭代器：2个类，iterable和iterator作为2个类分开实现，iterable中的iter返回iterator；iterator中的iter返回self，next逐个返回值。
糟糕的迭代器：1个类，同时在iterable中实现了iterator，即iterable中的iter返回self，同时具有next方法逐个返回值。
生成器：1个类，iterable的iter返回yield生成器。
惰性生成器：1个类，iterable的iter返回yield生成器，但是生成器的内容是惰性获取，例如获取文本时由finditer替代findall。
生成器表达式：1个类，iterable的iter返回一个生成器表达式。
多层for循环时，可以用yield from替代内层for循环

第十五章，上下文管理器和else块
用法：with xxx as yyy
支持同时打开两个对象：with xxx as yyy, aaa as bbb
上下文管理器协议：__enter__方法中返回yyy（没有提供内容时直接返回None），__exit__方法中做好退出释放资源操作

第十六章，协程
进程：有独立内存空间。
线程：CPU调度最小单位，共享内存。
协程：用户态的轻量级线程，上下文切换块，CPU感知不到协程，只使用一个线程。
在其他语言中，协程意义不大，可以通过多线程解决I/O，但是python有GIL多线程也是伪多线程，同一时间只能有一个线程，同步编程I/O阻塞称为瓶颈，可以用协程处理高I/O操作。
同步编程并发：单纯通过多进程和多进程进行同步编程，切换线程和切换进程有开销，还需要解决进程间/线程间资源交互问题。
异步编程并发：协程，回调。
协程： a = yield b，先执行b产出值；再执行a赋值；可以没有a，即只产出不赋值（生成器）；可以没有b，即只赋值不产出值（最后一起返回）。
协程流程：
1）预激：手动next; 装饰器; yield from；
2）发送至：send；
3）关闭：发送哨符值; close(); throw()输入未捕捉的异常
4）异常处理：throw()输入except捕捉的异常
5) 获取协程返回值：PEP380定义; yield from；

第十七章，使用future处理并发
I/O密集型：多线程threading —> futures.ThreadPoolExecutor
CPU密集型：多进程multiprocessing —> futures.ProcessExecutor
python有GIL，同一时间只能允许一个线程执行python字节码，而线程是调度CPU的最小单位，因此多线程无法满足CPU密集型操作。其他语言开启多线程可以调度多个CPU的可以满足CPU密集型操作。
futures多进程/多线程处理方法：
map：全部完成后获取结果，再执行后续代码，只能处理相同的函数（函数参数可以不同）
submit + as_completed：有完成的就先获取结果，可处理不同函数

第十八章，使用asyncio包处理并发
asyncio用于异步IO
python3.5开始引入了新语法async和await：@asyncio.coroutine替换为async def …，yield from替换为await

第十九章，动态属性和特性
如果想把属性x变成只读：可以通过@property完成，特性名称需要与init中静态属性名称不同，因为如果相同没有提供setter方法无法完成赋值。
如果想限制静态属性：可以增加@x.setter装饰同名函数，静态属性名称self.x，@property特性名称x，@x.setter装饰的名称x三者相同，这时setter中的函数可以实现一些限制和验证操作，如果不做这些操作那就可以不用property和setter。

第二十章，属性描述符
限制静态属性的方法：
1）init函数中判断并raise error，缺点是只有实例化时有效，实例化后无法限制对属性进行更改
2）@property + @xx.setter，缺点是不能重复使用，有多个属性想限制时代码量会非常大
3）描述符

第二十一章，元类编程
待补充