《流畅的python》是一本适合python进阶的书, 里面介绍的基本都是高级的python用法. 对于初学python的人来说, 基础大概也就够用了, 但往往由于够用让他们忘了深入, 去精通. 我们希望全面了解这个语言的能力边界, 可能一些高级的特性并不能马上掌握使用, 因此这本书是工作之余, 还有余力的人来阅读, 我这边就将其有用, 精妙的进阶内容整理出来.

这本书有21个章节, 整理也是根据这些章节过来.

这部分主要介绍了python的魔术方法, 它们经常是两个下划线包围来命名的(比如 __init__ , __lt__, __len__ ). 这些特殊方法是为了被python解释器调用的, 这些方法会注册到他们的类型中方法集合中, 相当于为cpython提供抄近路. 这些方法的速度也比普通方法要快, 当然在自己不清楚这些魔术方法的用途时, 不要随意添加.

关于字符串的表现形式是两种, __str__ 与 __repr__ . python的内置函数 repr 就是通过 __repr__ 这个特殊方法来得到一个对象的字符串表示形式. 这个在交互模式下比较常用, 如果没有实现 __repr__ ,

两者还有一个区别, 在字符串格式化时, "%s" 对应了 __str__ . 而 "%r" 对应了 __repr__. __str__ 和 __repr__ 在使用上比较推荐的是，前者是给终端用户看，而后者则更方便我们调试和记录日志.

第二章: 序列构成的数组

这部分主要是介绍序列, 着重介绍数组和元组的一些高级用法.

序列按照容纳数据的类型可以分为:

• 这里的 __iter__ 不是生成器函数了, 而是使用生成器表达式构建生成器, 最终的效果一样. 调用 __iter__ 方法会得到一个生成器对象.

  生成器表达式是语法糖, 完全可以替换生成器函数.

  标准库提供了很多生成器, 有用于逐行迭代纯文本文件的对象, 还有出色的 os.walk 函数. 这个函数在遍历目录树的过程中产出文件名, 因此递归搜索文件系统像 for 循环那样简单.

  并行处理两个可迭代的对象；如果 selector_it 中的元素是真值，产出 it 中对应的元素
  处理 it，跳过 predicate 的计算结果为真值的元素，然后产出剩下的各个元素（不再进一步检查）

  产出累积的总和；如果提供了 func，那么把前两个元素传给它，然后把计算结果和下一个元素传给它，以此类推，最后产出结果
  把 it 中的各个元素传给func，产出结果；如果传入 N 个可迭代的对象，那么 func 必须能接受 N 个参数，而且要并行处理各个可迭代的对象

  合并多个可迭代对象的生成器函数

  先产出 it1 中的所有元素，然后产出 it2 中的所有元素，以此类推，无缝连接在一起
  产出 it 生成的各个可迭代对象中的元素，一个接一个，无缝连接在一起；it 应该产出可迭代的元素，例如可迭代的对象列表
  并行从输入的各个可迭代对象中获取元素，产出由 N 个元素组成的元组，只要有一个可迭代的对象到头了，就默默地停止

  如果生成器函数需要产出另一个生成器生成的值, 传统的方式是嵌套的 for 循环, 例如, 我们要自己实现 chain 生成器:

  chain 生成器函数把操作依次交给接收到的可迭代对象处理. 而改用 yield from 语句可以简化:

  有些函数接受可迭代对象, 但仅返回单个结果, 这类函数叫规约函数.

  it 中所有元素的总和，如果提供可选的 start，会把它加上（计算浮点数的加法时，可以使用 math.fsum 函数提高精度）
  返回 it 中值最大的元素；*key 是排序函数，与 sorted 函数中的一样；如果可迭代的对象为空，返回 default
  把前两个元素传给 func，然后把计算结果和第三个元素传给 func，以此类推，返回最后的结果；如果提供了 initial，把它当作第一个元素传入

  第十五章: 上下文管理器和 else 块

  本章讨论的是其他语言不常见的流程控制特性, 正因如此, python新手往往忽视或没有充分使用这些特性. 下面讨论的特性有:

  • with 语句和上下文管理器

with 语句会设置一个临时的上下文, 交给上下文管理器对象控制, 并且负责清理上下文. 这么做能避免错误并减少代码量, 因此API更安全, 而且更易于使用. 除了自动关闭文件之外, with 块还有其他很多用途.

else 子句先做这个，选择性再做那个的作用.

else 子句的行为如下:

在所有情况下, 如果异常或者 return , break 或 continue 语句导致控制权跳到了复合语句的住块外, else 子句也会被跳过.

这一些情况下, 使用 else 子句通常让代码更便于阅读, 而且能省去一些麻烦, 不用设置控制标志作用的变量和额外的if判断.

上下文管理器和with块

上下文管理器对象的目的就是管理 with 语句, with 语句的目的是简化 try/finally 模式. 这种模式用于保证一段代码运行完毕后执行某项操作, 即便那段代码由于异常, return 或者 sys.exit() 调用而终止, 也会执行执行的操作. finally 子句中的代码通常用于释放重要的资源, 或者还原临时变更的状态.

with 最常见的例子就是确保关闭文件对象.

• exc_value : 异常实例。有时会有参数传给异常构造方法，例如错误消息，这些参数可以使用 exc_value.args 获取

在ptyhon的标准库中, contextlib 模块中还有一些类和其他函数，使用范围更广。

• suppress: 构建临时忽略指定异常的上下文管理器。
• @contextmanager: 这个装饰器把简单的生成器函数变成上下文管理器，这样就不用创建类去实现管理器协议了。
• ContextDecorator: 这是个基类，用于定义基于类的上下文管理器。这种上下文管理器也能用于装饰函数，在受管理的上下文中运行整个函数。
• ExitStack: 这个上下文管理器能进入多个上下文管理器。with 块结束时，ExitStack 按照后进先出的顺序调用栈中各个上下文管理器的 __exit__ 方法。如果事先不知道 with 块要进入多少个上下文管理器，可以使用这个类。例如，同时打开任意一个文件列表中的所有文件。

显然，在这些实用工具中，使用最广泛的是 @contextmanager 装饰器，因此要格外留心。这个装饰器也有迷惑人的一面，因为它与迭代无关，却要使用 yield 语句。

yield 语句起到了分割的作用, yield 语句前面的所有代码在 with 块开始时（即解释器调用 __enter__ 方法时）执行， yield 语句后面的代码在 with 块结束时（即调用 __exit__ 方法时）执行.

为了理解协程的概念, 先从 yield 来说. yield item 会产出一个值, 提供给 next(...) 调用方; 此外还会做出让步, 暂停执行生成器, 让调用方继续工作, 直到需要使用另一个值时再调用 next(...) 从暂停的地方继续执行.

从句子语法上看, 协程与生成器类似, 都是通过 yield 关键字的函数. 可是, 在协程中, yield 通常出现在表达式的右边(datum = yield), 可以产出值, 也可以不产出(如果yield后面没有表达式, 那么会产出None). 协程可能会从调用方接收数据, 不过调用方把数据提供给协程使用的是

生成器调用方是一直索要数据, 而协程这是调用方可以想它传入数据, 协程也不一定要产出数据.

不管数据如何流动, yield 都是一种流程控制工具, 使用它可以实现写作式多任务: 协程可以把控制器让步给中心调度程序, 从而激活其他的协程.

协程的底层框架实现后, 生成器API中增加了 .send(value) 方法. 生成器的调用方可以使用 .send(...) 来发送数据, 发送的数据会变成生成器函数中 yield 表达式的值. 因此, 生成器可以作为协程使用. 除了 .send(...) 方法, 还添加了

用作协程的生成器的基本行为

在 yield 表达式中, 如果协程只需从调用那接受数据, 那么产出的值是 None . 与创建生成器的方式一样, 调用函数得到生成器对象. 协程都要先调用 next(...) 函数, 因为生成器还没启动, 没在 yield 出暂定, 所以一开始无法发送数据. 如果控制器流动到协程定义体末尾,

使用协程的好处是不用加锁, 因为所有协程只在一个线程中运行, 他们是非抢占式的. 协程也有一些状态, 可以调用 inspect.getgeneratorstate(...) 来获得, 协程都是这4个状态中的一种:

只有在多线程应用中才能看到这个状态。此外，生成器对象在自己身上调用 getgeneratorstate 函数也行，不过这样做没什么用。

为了更好理解继承的行为, 来看看产生两个值的协程:

关键的一点是, 协程在 yield 关键字所在的位置暂停执行. 对于 b = yield a 这行代码来说, 等到客户端代码再激活协程时才会设定 b 的值. 这种方式要花点时间才能习惯, 理解了这个, 才能弄懂异步编程中 yield 的作用. 对于实例的代码中函数

示例：使用协程计算移动平均值

这是一个动态计算平均值的协程代码, 这个无限循环表明, 它会一直接收值然后生成结果. 只有当调用方在协程上调用 .close() 方法, 或者没有该协程的引用时, 协程才会终止.

协程的好处是, 无需使用实例属性或者闭包, 在多次调用之间都能保持上下文.

如果没有执行 next(...) , 协程没什么用. 为了简化协程的用法, 有时会使用一个预激装饰器.

协程中未处理的异常会向上冒泡, 传给 next() 函数或者 send() 的调用方. 如果这个异常没有处理, 会导致协程终止.

这要求在协程内部要处理这些异常, 另外, 客户端代码也可以显示的发送异常给协程, 方法是 throw 和 close :

协程内部如果不能处理这个异常, 就会导致协程终止.

而 close 是致使在暂停的 yield 表达式处抛出 GeneratorExit 异常. 协程内部当然允许处理这个异常, 但收到这个异常时一定不能产出值, 不然解释器会抛出 RuntimeError 异常.

为了返回值, 协程必须正常终止, 而正常终止的的协程会抛出 StopIteration 异常, 因此需要调用方处理这个异常.

yield from x 表达式对 x 对象所做的第一件事是, 调用 iter(x) 获得迭代器. 因此, x 对象可以是任何可迭代对象.

这个语义过于复杂, 来看看作者 Greg Ewing 的解释:

“把迭代器当作生成器使用，相当于把子生成器的定义体内联在 yield from 表达式
中。此外，子生成器可以执行 return 语句，返回一个值，而返回的值会成为 yield
from 表达式的值。”

, 那么会调用子生成器的 send() 方法. 当子生成器抛出 StopIteration 异常, 那么委派生成器恢复运行. 任何其他异常都会向上冒泡, 传给委派生成器.

第十七章: 使用期物处理并发

示例：网络下载的三种风格

为了高效处理网络io, 需要使用并发, 因为网络有很高的延迟, 所以为了不浪费 CPU 周期去等待.

以一个下载网络 20 个图片的程序看, 串行下载的耗时 7.18s . 多线程的下载耗时 1.40s, asyncio的耗时 1.35s . 两个并发下载的脚本之间差异不大, 当对于串行的来说, 快了很多.

CPython解释器不是线程安全的, 因此有全局解释锁(GIL), 一次只允许使用一个线程执行 python 字节码, 所以一个python进程不能同时使用多个 CPU 核心.

python程序员编写代码时无法控制 GIL, 然而, 在标准库中所有执行阻塞型I/O操作的函数, 在登台操作系统返回结果时都会释放GIL. 这意味着IO密集型python程序能从中受益.

并发是指一次处理多件事。
并行是指一次做多件事。
二者不同，但是有联系。
一个关于结构，一个关于执行。
并发用于制定方案，用来解决可能（但未必）并行的问题。—— Rob Pike Go 语言的创造者之一

并行是指两个或者多个事件在同一时刻发生, 而并发是指两个或多个事件在同一时间间隔发生. 真正运行并行需要多个核心, 现在笔记本一般有 4 个 CPU 核心, 但是通常就有超过 100 个进程同时运行. 因此, 实际上大多数进程都是并发处理的, 而不是并行处理. 计算机始终运行着 100 多个进程, 确保每个进程都有机会取得发展, 不过 CPU 本身同时做的事情不会超过四件.

本章介绍 asyncio 包, 这个包使用事件循环驱动的协程实现并发. 这个库有龟叔亲自操刀. asyncio 大量使用 yield from 表达式, 因此不兼容 python3.3 以下的版本.

一个借由 threading 模块使用线程, 一个借由 asyncio 包使用协程实现来进行比对.

这是使用 threading 的案例, 让子线程在 3 秒内不断打印, 在python中, 没有提供终止线程的API. 若想关闭线程, 必须给线程发送消息.

这两种 supervisor 实现之间的主要区别概述如下:

• Task 对象用于驱动协程，Thread 对象用于调用可调用的对象。
• 获取的 Task 对象已经排定了运行时间（例如，由 asyncio.async 函数排定）；Thread 实例则必须调用 start 方法，明确告知让它运行。
• 没有 API 能从外部终止线程，因为线程随时可能被中断，导致系统处于无效状态。如果想终止任务，可以使用 Task.cancel() 实例方法，在协程内部抛出 CancelledError 异常。协程可以在暂停的 yield 处捕获这个异常，处理终止请求。

多线程编程是比较困难的, 因为调度程序任何时候都能中断线程, 必须记住保留锁, 去保护程序中重要部分, 防止多线程在执行的过程中断.

而协程默认会做好全方位保护, 以防止中断. 我们必须显示产出才能让程序的余下部分运行. 对协程来说, 无需保留锁, 而在多个线程之间同步操作, 协程自身就会同步, 因为在任意时刻, 只有一个协程运行.

从期物、任务和协程中产出

为了执行这个操作, 必须排定协程的运行时间, 然后使用 asyncio.Task 对象包装协程. 对协程来说, 获取 Task 对象主要有两种方式:

• 关键字参数是可选的，用于传入事件循环；如果没有传入，那么 async 函数会通过调用 asyncio.get_event_loop() 函数获取循环对象。

asyncio.wait(...) 协程参数是一个由期物或协程构成的可迭代对象, wait 会分别把各个协程装进一个 Task 对象. 最终的结果是, wait 处理的所有对象都通过某种方式变成 Future 类的实例. wait 是协程函数, 因此返回的是一个协程或生成器对象. 为了驱动协程, 我们把协程传给

有两种方法能避免阻塞型调用中止整个应用程序的进程:

• 在单独的线程中运行各个阻塞型操作
• 把每个阻塞型操作转换成非阻塞的异步调用使用

多线程是可以的, 但是会消耗比较大的内存. 为了降低内存的消耗, 通常使用回调来实现异步调用. 这是一种底层概念, 类似所有并发机制中最古老最原始的那种--硬件中断. 使用回调时, 我们不等待响应, 而是注册一个函数, 在发生某件事时调用. 这样, 所有的调用都是非阻塞的.

异步应用程序底层的事件循环能依靠基础设置的中断, 线程, 轮询和后台进程等待等, 确保多个并发请求能取得进展并最终完成, 这样才能使用回调. 事件循环获得响应后, 会回过头来调用我们指定的回调. 如果做法正确, 事件循环和应用代码公共的主线程绝不会阻塞.

把生成器当做协程使用是异步编程的另一种方式. 对事件循环来说, 调用回调与在暂停的协程上调用 .send() 效果差不多.

使用Executor对象，防止阻塞事件循环

访问本地文件会阻塞, 而CPython底层在阻塞型I/O调用时会释放 GIL, 因此另一个线程可以继续.

因为 asyncio 事件不是通过多线程来完成, 因此 save_flag 用来保存图片的函数阻塞了与 asyncio 事件循环共用的唯一线程, 因此保存文件时, 真个应用程序都会冻结. 这个问题的解决办法是, 使用事件循环对象的 run_in_executor 方法.

第十九章: 动态属性和特性

在python中, 数据的属性和处理数据的方法都可以称为 属性 . 除了属性, pythpn 还提供了丰富的 API, 用于控制属性的访问权限, 以及实现动态属性, 如 obj.attr 方式和 __getattr__ 计算属性.

动态创建属性是一种元编程,

使用 new 方法以灵活的方式创建对象

我们通常把 __init__ 成为构造方法, 这是从其他语言借鉴过来的术语. 其实, 用于构造实例的特殊方法是 __new__ : 这是个类方法, 必须返回一个实例. 返回的实例将作为以后的 self 传给 __init__ 方法.

第二十章: 属性描述符

覆盖型与非覆盖型描述符对比

python存取属性的方式是不对等的. 通过实例读取属性时, 通常返回的是实例中定义的属性, 但是, 如果实例中没有指定的属性, 那么会从获取类属性. 而实例中属性赋值时, 通常会在实例中创建属性, 根本不影响类.

这种不对等的处理方式对描述符也有影响. 根据是否定义 __set__ 方法, 描述符可分为两大类: 覆盖型描述符和与非覆盖型描述符.

实现 __set__ 方法的描述符属于覆盖型描述符, 因为虽然描述符是类属性, 但是实现 __set__ 方法的话, 会覆盖对实例属性的赋值操作. 因此作为类方法的 __set__ 需要传入一个实例 instance . 看个例子:

没有 __get__ 方法的覆盖型描述符

只有在赋值操作的时候才回覆盖行为.

python的类中定义的函数属于绑定方法, 如果用户定义的函数都有 __get__ 方法, 所以依附到类上, 就相当于描述符.

函数都是非覆盖型描述符. 在函数上调用 __get__ 方法时传入实例作为 self , 得到的是绑定到那个实例的方法. 调用函数的 __get__ 时传入的 instance 是 None , 那么得到的是函数本身. 这就是形参 self 的隐式绑定方式.

只读描述符必须有 set 方法
如果要实现只读属性, __get__ 和 __set__ 两个方法必须都定义, 柔则, 实例的同名属性会覆盖描述符.

用于验证的描述符可以只有 set 方法
什么是用于验证的描述符, 比方有个年龄属性, 但它只能被设置为数字, 这时候就可以只定义 __set__ 来验证值是否合法. 这种情况不需要设置 __get__ , 因为实例属性直接从 __dict__ 中获取, 而不用去触发 __get__ 方法.

第二十一章: 类元编程

类元编程是指在运行时创建或定制类的技艺. 在python中, 类是一等对象, 因此任何时候都可以使用函数创建类, 而无需使用 class 关键字. 类装饰器也是函数, 不过能够审查, 修改, 甚至把被装饰的类替换成其他类.

元类是类元编程最高级的工具. 什么是元类呢? 比如说 str 是创建字符串的类, int 是创建整数的类. 那么元类就是创建类的类. 所有的类都由元类创建. 其他 class 只是原来的"实例".

本章讨论如何在运行时创建类.

标准库中就有一个例子是类工厂函数--具名元组( collections.namedtuple ). 我们把一个类名和几个属性传给这个函数, 它会创建一个 tuple 的子类, 其中的元素通过名称获取.

假设我们创建一个 record_factory , 与具名元组具有相似的功能:

我们要做一个在运行时创建类的, 类工厂函数:

在python中做元编程时, 最好不要用 exec 和 eval 函数. 这两个函数会带来严重的安全风险.

元类是制造类的工厂, 不过不是函数, 本身也是类. 元类是用于构建类的类.

type 构造方法以及元类的 __new__ 和 __init__ 方法都会收到要计算的类的定义体, 形式是名称到属性的映像. 在默认情况下, 这个映射是字典, 属性在类的定义体中顺序会丢失. 这个问题的解决办法是, 使用python3引入的特殊方法 __prepare__ , 这个方法只在元类中有用, 而且必须声明为类方法(即要使用 @classmethod 装饰器定义). 解释器调用元类的 __new__ 方法之前会先调用 __prepare__ 方法, 使用类定义体中的属性创建映射.

__prepare__ 的第一个参数是元类, 随后两个参数分别是要构建类的名称和基类组成的原则, 返回值必须是映射.

python是一门即容易上手又强大的语言.