最近做了一些豆瓣的产品业务代码的 Python 3 迁移相关的准备工作。首先当然是要去改那些基础 Model，除了代码符合 Python3 语法要求，这种基础的、核心的代码也要加上类型注解，结果一上来就遇到个问题，和大家分享下。 下面是一个模拟的简单版本的例子（豆瓣厂工和前厂工会理解这种写法😋）

from typing import Union
from dataclasses import dataclass

import pymysql.cursors

connection = pymysql.connect(host='localhost',
                             user='root',
                             password='',
                             db='test',
                             charset='utf8mb4')


@dataclass
class Subject:
    id: int
    cat_id: int
    title: str
    kind: int = 0

    @classmethod
    def get(cls, id: int) -> Union[Subject, None]:
        with connection.cursor() as cursor:
            cursor.execute(
                "select id, cat_id, title, kind from subject where id=%s", id)
            rs = cursor.fetchone()
        if not rs:
            return None
        return cls(*rs)

    def set_cover(self, cover: ImageCover):
        ...


@dataclass
class ImageCover:
    id: int
    identifier: str

我简单介绍下上面这段代码要做的事情：

1. 用 dataclass 装饰器可以帮你生成 init、repr_ 和比较相关的各种魔术方法、同时添加字段验证等等，极高了提高了生产力。具体可以看我之前写的 attrs 和 Python3.7 的 dataclasses ，上例 Subject 包含了 id、title、kind、cat_id 四个字段
2. Subject 包含一个 get 方法，通过 id 可以拿到对应的 Subject 实例，如果数据库找不到会返回 None，所以类型注解中用了 Union。

Python 是一种动态类型化的语言，不会强制使用类型提示，所以我们要借用外部的工具 mypy 做类型检查：

➜  pip3 install mypy --user
➜  mypy ~/workspace/movie/movie/models/base.py

mypy 的执行结果没有返回内容，说明我写的类型注解没有问题。但是运行不了

In [1]: from movie.models.base import Subject
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-1-b027a5ff7e8f> in <module>
----> 1 from a import Subject

~/workspace/movie/movie/models/base.py in <module>
     12
     13
---> 14 @dataclass
     15 class Subject:
     16     id: int

~/workspace/movie/movie/models/base.py in Subject()
     20
     21     @classmethod
---> 22     def get(cls, id: int) -> Union[Subject, None]:
     23         with connection.cursor() as cursor:
     24             cursor.execute(

NameError: name 'Subject' is not defined

即使把 Union[Subject, None] 这部分去掉，下面的 ImageCover 那部分也会抛错：

29         return cls(*rs)
     30
---> 31     def set_cover(self, cover: ImageCover):
     32         ...
     33

NameError: name 'ImageCover' is not defined

这个问题可以看 PEP 563 ，简单地说是因为类型注解部分求值太早了，那个时候类还没创建完！

怎么办呢？让类型注解「延迟求值」，使用 Python 3.7 新加入的方案：

from __future__ import annotations
from typing import Union
from dataclasses import dataclass

...

添加第一行，这样就可以了。

使用字符串替代类

第二次更新： 2018-12-30 19:55:57

文章发出后，@abc.zxy 和 @杨恺 Thomas Young 同学都提出了另外一个解决方案，就是使用对应字符串作为类型值：

@dataclass
class Subject:
    id: int
    cat_id: int
    title: str
    kind: int = 0

    @classmethod
    def get(cls, id: int) -> Union['Subject', None]:  # Subject是字符串
        with connection.cursor() as cursor:
            cursor.execute(
                "select id, cat_id, title, kind from subject where id=%s", id)
            rs = cursor.fetchone()
        if not rs:
            return None
        return cls(*rs)

    def set_cover(self, cover: 'ImageCover'):  # ImageCover是字符串
        ...

可以看到不使用 fromfutureimport annotations，这样的写法也是正常运行的。具体的可以看延伸阅读链接的 mypy 方案。而 PEP 484 也进行过讨论

这就引起了我的求知欲，既然 mypy 已经提供了解决方案，哪官方为什么要强烈的实现「延迟求值」这个特性呢？

看了下延伸阅读链接 2 里面「Typing Enhancements」部分做的解释，我汇总下观点：

Python 是一个动态语言，运行时不会做类型检查。本来在代码中添加类型注释是不应该响应性能的，但是很不幸，如果使用了 typing 模块就会影响到。

在之前的例子中，get 方法可能返回 None 或者一个 Subject 对象，就得用到 typing.Union 了。为什么会影响性能呢？

原来 typing 模块是标准库中最慢的模块了 ！！所以在 Python3.7 大体做了 2 个角度的优化：

1. 通过实现 PEP 560 让 typing 模块大大提速
2. 通过实现 PEP 563 让类型注解延迟求值，因为类型提示没有执行

虽然前面用字符串替代类的方式可用。但是性能上可能会有影响，如果你已经在用 Python3.7 或者更高版本，理应选择 fromfutureimport annotations 这种方式。

google/pytype

三次更新： 2018-12-31 18:00:00

感谢 @laike9m 推荐的 https://github.com/google/pytype ，可以用它做静态检查和推断未注释 Python 代码的类型:

➜  cat foo.py
def make_greeting(user_id):
    return 'hello, user' + user_id

def print_greeting():
    print(make_greeting(0))
➜  pytype-single foo.py
File "foo.py", line 2, in make_greeting: unsupported operand type(s) for +: 'str' and 'int' [unsupported-operands]
  Function __add__ on str expects str
Called from (traceback):
  line 5, in print_greeting

For more details, see https://github.com/google/pytype/blob/master/docs/errors.md#unsupported-operands.

除了 mypy 也可以考虑下 Google 的 pytype ，毕竟是在生产环境下大厂成熟应用案例。

延伸阅读

1. https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html#miscellaneous
2. https://realpython.com/python37-new-features/
3. https://www.python.org/dev/peps/pep-0563/

原文: from __future__ import annotations

先申明这不是一篇技术文章，只是用叙事的方式讲述我这 2 个礼拜由于结石住院的始末。结石是一种很常见的泌尿系统疾病，我认识的不少人都有过结石，我的感觉里面程序员或者说互联网从业者会更容易得这个病，那为什么写这篇文章呢？一则这个过程还是比较戏剧化的，对我来说真的是起伏跌宕，甚至现在对这个结果还有点懵逼，把这些记录下来并且回溯和反思权当回忆了，再则希望分享我的经历和经验让大家能了解和重视结石问题，最后衷心希望大家不要感受结石发作时的痛苦。

一次征兆

住院前的一个礼拜左右的某一天晚上，我被右后腰的一种酸痛疼醒了，这种疼有点像着凉引起的，而且当时我觉得可能由于睡觉姿势之类引起的，但是继续入睡又疼的睡不着，后来迷迷糊糊的不知道换了什么体位疼痛就消失，我又重新睡着了。一觉醒来一切无恙，之后几天再无这种情况，也就没当回事。

现在想想，这就是一个征兆，是身体给我的一个提醒，应该是结石的位置恰巧到了一个不舒服的位置把我疼醒的，后来翻来覆去睡不着过程中改变了它的位置又相安无事。

发作

8 月 13 日（发作前一天）夜间开窗户可能是着凉了，早上起来腹泻好几次，期间下腹有绞痛和后腰的酸疼，我赶紧喝了些热水，还依照过去的腹泻经验盖着被子把热水瓶放在肚子上，就这样很快绞痛的感觉渐渐消失了，然后我正常上班去了。

前一天的腹泻没怎么当回事，8 月 14 日夜间又开窗户了，结果早上起床又腹泻三次，同样还有下腹的绞痛的感觉，头冒冷汗，尝试了一会前一天的方法，症状没有减轻甚至有些加重的倾向。大概这样不舒服了半个小时，觉得情况不对，当时我的感觉是急性肠胃炎之类的，不能再等了，决定去医院！但结果这天恰巧下雨，不好打车，在小区门口等了可能 20 分钟的样子才打到出租车。

当时觉得一点小问题嘛，大医院又远排队又太麻烦，就找了最近的一个社区性质的医院，此时大概 8 点多，想着处理完还可以继续上班。结果到了医院，人家说不接我这腹泻类型的肠道急诊... 说最近的能接肠道急诊是华信医院，这个医院我之前去过，离公司也近。不墨迹赶紧打车，应该这个时候开始有憋尿的小腹下坠和拉扯的感觉了，结果还是由于下雨，而且我上班那条路本来也容易堵车，到华信大概耗时 40 分钟（平时打车也就 10 来分钟），在车上我的小腹下坠感觉越来越明显，同时下腹绞痛和后腰酸痛的感觉也越来越重。在出租车上这多半个小时非常煎熬，那种疼虽然没有和并有交流的一种刀割般那么疼，但疼是持续的，让人坐立不安，我很多次真的想下车自己跑去医院。

现在想想，13 日结石应该就在输尿管中段狭窄处了，13 和 14 日早上一开始是不疼的，几次腹泻之后才开始有痛感，也就是排尿很多或者上厕所的姿势等因素触发了结石痛。

肠道急诊

到了华信医院就赶紧去挂急诊了，本来就按着肠道问题来看的，然后挂号、抽血，当时医生是希望做便检确认问题的（非必须），但此时我已经小便不出，且恰由于早上腹泻多次，实在搜集不到。我只能在急诊处多喝水等待。疼痛的感觉有增无减，血结果大概半小时出来，医生说结果没什么特别明显的异常，医生比较年轻看起来经验不多，定位不了我的问题，就这样不明原因的过了差不多一个小时，期间找了几次医生描述我疼痛的情况，医生后来说那验个尿吧。这个时候实在疼痛难忍，先护士先给我打了一个止痛针，然鹅对于我的疼痛完全没有效果。我不断的喝水，小便不夸张的说是稀沥沥按滴数的，为了凑够验尿的量，我前后喝了 5 瓶矿泉水，去了不下 10 次厕所，总算勉强凑够了。接着就是等待尿检结果，结果一出来，红细胞很多，也就是尿中有血（肉眼分辨不出来），医生说「你这样像是结石」呀！然后开了 B 超和 CT 的单子，我离开了急诊，去门诊楼了。

离开急诊大概 11 点了。也就是说我在这里干疼了 2 小时，而且由于喝了很多水，让小腹下坠的疼痛感觉更厉害了。

确认结石

离开急诊后去门诊楼做检查，好像急诊来的可以优先，而且 11 点这个时间点人也比较少，倒是不需要排队，但是由于要憋尿，又是再喝水，CT 做的比较晚，中午 12 点半才做（其实已经下班，急诊的可以按铃），等了差不多 20 分钟拿到了 CT 结果。

2 个结果都证明有结石。我拿回急诊给医生看，医生告诉我去「泌尿外科」，并帮我挂了个号。

急诊做检查取结果要比门诊的更快，比如 CT 门诊要等一个小时，急诊的就半个小时，而且我这个不够半小时就拿到了。如果着急请挂急诊，门诊效率相比太低了。

门诊下午 1 点才开诊，但幸好这个医院泌尿外科看病人很少，我很快就看上了。医生告诉我，右侧输尿管有一个大约 5 毫米的结石，且有轻度肾盂和上段输尿管积水。听起来 5 毫米也不大嘛，但是要注意输尿管是很窄的，我翻了下资料，它直径平均 5-7 毫米，有三处狭窄的地方 1-2 毫米，可见我这个结石还是很大的，直接堵死了右侧输尿管，梗阻了。

确认结石时大概 13 点半，我这个时候还在疼，医生说这种疼普通的止疼针是没有效果的，立竿见影的办法就是住院打杜冷丁。虽然极度不想住院，也不想打这种听起来是绝症病人才用的药，但是这个疼一直持续真的太痛苦，此时我只想止疼。

住院

接着就是办理住院手续，在护士站登记后入病房，换了病号服。我的感觉是打针对疼痛有缓解但是还是疼，不一会我的主治医生找我，了解病情并和我沟通情况，提了 2 种治疗方案：

1. 直接做手术（经皮肾镜微创取石）。虽然是微创的，但也要有 1cm 左右的伤口。
2. 先体外碎石（即体外冲击波碎石术，ESWL）。看看能不能碎掉结石，如果能碎掉就没有必要做手术了。这里引出一句话， 碎石并不一定成功 ，而且医生一开始就和我说看 CT 的片子中结石发亮，感觉质地比较硬。

正是由于腹泻，暴露了结石的问题。让我在早期痛苦时就发现并就医了，护士长说通常结石病人住院时哭天喊地、要死要活、直不起腰的情况，我这算是轻的了。万幸吧！

做手术的话预计费用 2.5w，医保可报 70%，但是由于豆瓣有补充医疗保险，基本上我不花什么钱。但是我还是选择方案 2，主要是对手术的恐惧，希望身体是「完整」没有开过刀的，而且听说别人说好像都是自己排或者体外碎石出来的，我又这么年轻有什么必要直接做手术呢？

第一次碎石

沟通后不久，主治医生就带我去碎石室碎石。每次碎石冲击波共 2500 次，过程不到半小时，有时候打下来可能正中结石位置会比较疼，其余大部分疼痛能接受：据说有人在碎石过程中能睡着我也是服。

碎完就有一种能尿出来的感觉，感觉非常好，回病房不久就能排尿了，当然第一次是血尿，比较浑浊，医生要求每次都要接尿看是否有东西排出。碎石后会开始输液，在几个小时内会有感觉疼痛家加剧，但是输液非常利尿，随着我不断的排尿所有的疼痛感渐渐的就消失了，尿液颜色也逐渐正常了。

嗯，到输液完成大概凌晨 1 点。此时我已经完全不疼，像极了一个正常人。

这一天正好是我的生日，非常特别，第一次住院，基本一整天都是疼痛中度过。

第二次碎石前

接着几天模式都差不多：

1. 上午 / 下午到点输液
2. 多喝水，喝水喝到想吐，后来不得不来点脉动、力量帝之类的果味的饮料缓解下
3. 多运动。就是蹦蹦跳跳，溜达，找同层病友聊个天什么的。

不过和预想的不一样，再也没有第一天那样疼过，我住院就是担心会往复的那种疼，有时候会有一些疼痛的感觉，但比较轻，而且很快疼痛会消失。

我这个人既来之则安之，都住院了，索性有什么不舒服的都提出来，然后就是做各种检查。这样总比我起个大早挂号再排队检查体验好得多。住院的做检查往往有很多优待，有专门的通道，专人送到住院部等等，另外穿着病号服去排队，往往能收获很多关爱的眼神😁

医院对住院病人管理不严，可以随意出入医院，我经常穿着病号服去门口小卖部买饮料：一眼看去真不想一个病人。

这个过程整体来说我还是很轻松的，一直不疼应该预示着石头已经排掉了，但我一直没有看到碎石后产生的碎渣之类的东西，还是有一丝忐忑。

第二次碎石

一周后的 21 日，又拍了一次 B 超和 CT，这次 B 超没找到结石，其中一个原因是腹部有气看不清楚，但是依然有肾积水，做 B 超的医生说应该结石还在，我不开心了😒，之后的 CT 也证实了这一点。但好消息是结石比之前小了一些，不到 3 毫米，而且已经到了输尿管和膀胱连接处，这里是最后一处输尿管狭窄的部分，另外主治医生说结石颜色变浅了一些，可能碎的比较薄了一些。

所以这里大家注意，并不是一次碎石就能成功，他可能还在，只是暂时不作恶罢了。住院部有泌尿外科的一些结石，其中提到一次体外碎石成功率是 90%，嗯，我就是那 10% 😢

主治医生找我沟通下一步，有 2 个选择。做手术或者再碎一次，同样明确了再碎依然不能保证碎掉。我犹豫了一下，还是决定再碎一次。过程就不说了，和第一次碎石大体一样，但是碎的过程的疼痛明显比上一次厉害，好在医生同意我一边碎一边刷手机转移了一点注意力。

第二次碎石后

整个住院的过程中，病友们换了一拨又一拨，第二次碎石时就已经有病友出院了。有的病友碎石当场就会排出碎渣，然后直接出院了。同样结石的病友年龄都很大，40-60 的居多，像我这种比较年轻的是很少的，他们竟然这么快出院了，尤其是有些病友都不怎么喝水和运动（当然也受限于年龄），这对我来说压力越来越大，因为我这种结石虽然不疼，但是长时间的肾积水是不行的，第二次碎石后，我在喝水和运动这些方面上更努力和积极了，真不想走到动手术哪一步啊。有一种工期临近但是离做完还很遥远的无力感，甚至是要做倒计时的感觉了。

这段时间我基本每天喝水 4k 毫升以上，各种跳跃，上下楼梯等等，我也会翻一些网络上输尿管排石经验，试着去做，但一日复一日，完全没有结石的感觉。

到周五（24 日），希望越来越渺茫了，系主任查房时也说这积水时间有点长了，这么多天都没排出来，内窥镜取了吧。我为什么觉得结石没出来呢？有几点

1. 第二次碎石后的第一次血尿沉淀了一些浮沫，也能看到一些极小的碎屑，但是没有看到石头的碎渣，毕竟 3 毫米呢。主治医生看了后也觉得那些沉淀物不是结石
2. 整个排尿我都接了，完全没看到排除小石块之类的碎渣。
3. 排尿少。这也是我对石头还没出来的判断的重要依据。之前憋尿情况下，经常可以尿满一矿泉水瓶（500ml），这个时间点哪怕感觉要憋不住的情况也只能尿一半左右，仿佛有一边梗阻影响了排尿。其实我也会担心这种情况对肾积水的影响。

我当时选择做第二次碎石就是一种赌博，因为感觉我的结石形状不规则，并且有刺，我想很多病友都能排出来我的出不来，问医生说可能是有刺扎在某处下不来了，碎石可以让他能继续排出。但是到现在还是出不来，我觉得已经尽力了，那就做手术吧，然后找主治大夫约了下周一（27 日）的手术。

周五的心情

到周五时，已经开始送第二波病友，他们都是在我之后入院然后出院的。感觉医生，护士都对我这种情况有点无奈，我这个情况是什么呢？

1. 结石数量少。有些病友都是 2 个甚至三个
2. 结石尺寸小。第一次碎石时的 5 毫米还勉强入围一下，现在这不到 3 毫米的基本是人家最小那个的尺寸。看网上排石经验都没有我这么小的....
3. 住院周期长。绝大多数的病人都会在一周内出院，有些甚至单靠输液不做体外碎石就能排出，我这明显往 2 周上冲。
4. 我是最年轻的那一拨。病友动辄就 60 岁起步，和我同龄的不过 2-3 个，我住院期间只见过一个比我年龄小的男病人，且人家碎石后就排出来第二天出院了。

这个时候，心情是什么呢？有点尴尬？着急？好像没有语言能总结出来那种感受。唯一能够宽慰的是我并不是个例，还有一个妹子也是这样，虽然比我晚进来 2 天，但是没有排出来，心情应该和我一样。我俩在病房遇到第一句话总是『排出来了没？』，有点难兄难弟的感觉，捋了一遍，现在住院的这些除了几个病的中一些的，我俩是名副其实的「老人」。

最后的努力

周五时我已经不输液了，医生说我这种情况通过输液促进排尿和输尿管扩张的辅助作用已经意义不大了，和医生沟通了下反正住院也无事，周末我就回家，最后在努力一下，也是更好的休息一下，等待下周一手术。

其实周末对我来说，并没有抱多大希望，之前主治医生说碎石前三天排不出来之后恐怕也拍不出来了。不过我的性格就是，既然不能反抗就痛快的面对呗。但是该喝水该蹦跶一点也不会少。还买了跳绳。早中晚。初步算一下，不比医院的少，每天喝水 > 4k 毫升，跳绳次数 > 4k，这还不算散步或者高抬腿之类的运动。总之我会尽力到最后一天，即便结果看起来我的「赌」都是失败的，应该入院时就直接做手术省了很多罪。选择了就没什么可后悔的，对吧。

马上要手术了

本来预约周一比较晚了，我觉得可能得轮到下午。结果周一一大早医院打电话说我是上午第一个手术。匆忙间打车去医院，所幸并没有影响什么，刚到住院部就遇到主治医生，让我签了一堆东西，还给我开了 CT 让我再看看结石。我那时都已经放弃了，说直接做手术不用再看了吧？CT 也是一次辐射，最近做的次数有点多了。医生说肯定得看呀，万一结石没有了（我的内心是不信的），而且也得看看这一周结石在什么位置，方便手术确认，旁边一个医生做了一个比喻我忘记了，大意就是说 CT 的辐射量很小，我当时想做一个也好，万一结石马上出来了，医生说先不做了呢？

然后去下面等待拍 CT，太早了 CT 室还没上班多等了一会。等我排完回去正好遇到那个同样没排出来结石的女病友也来做 CT，她说：你的手术床都到了，等你了。嗯，有种待宰羔羊的感觉了。上楼后看到了那个手术床，仿佛完全没有回旋的余地了。这时护士找我做术准备了。

转折

护士备皮时，我已经在准备做手术时交代什么了：为啥这个小破结石就是不出来？是不是输尿管狭窄等问题，下次是不是再有结石我应该选择直接手术？你们要不要把那个结石拿去分析一下为啥 2 次都碎不掉？通过结石成分是不是说明我平时有什么有问题的饮食习惯... 等等。

我还在想问题时，听到我的主治医生在外面问其他护士，23 床进手术室没？然后朝我这个方向走来。那个时候我的心情其实已经是很平静的了。他推门进来，我还没来得及打招呼，就听它和护士说不用备皮了，手术不用做了。我当时的心情是：？？？？

然后他微笑的和我说，看你的 CT 片子石头已经没有了，肾积水也没了，所以不用做手术了。护士应该也没见过这么一种场景，有点愣住了，继续处理了一些，然后就出去了....

我不知道该用什么描述这时的心情，如果早上我来的早一些应该术前准备都做完了，可能已经被推进手术室了：它离我真的很近。

我从处置室出来都一直有点懵逼，第一感觉是检查报告是不是搞混了？回病房简单冲了个澡，不一会，主治医生过来找我说「你可以出院了」，我唯一的问题就是「为什么我完全没有感觉它排出来」，医生说应该是碎的非常彻底，又叮嘱我一些事情。半个小时后，本来我应该刚做完手术在病床上不能动，结果已经神奇的到公司上班了，这完全是一个天上一个地下呀。

其实现在回想，有几次排尿过程中尿道有疼痛感，排后疼痛感很久就小时了，不过我确实没看到有结石排出，可能是没看仔细？

另外，妹子的检查结果也出来了，结石没有了，它的主治医生也通知她出院了。嗯，这个结果是不是灰常圆满？

后记

以上就是整个过程了。那么问题来了，我为什么会得这个结石，结合医院墙壁上的一些资料和与病友聊天，觉得有下面几个方面的问题：

1. 缺乏运动。原来我是一个挺注重运动和锻炼的，但近 1-2 年，尤其是最近半年制作课程真的没有时间。之后还是要抽时间运动呀
2. 肉食动物。尤其爱吃动物内脏，其实最近 1-3 年越来越胖，也越来越有中年大叔的倾向，我已经在饮食里面注意了，每次吃都会有愧疚感。之后要更加注意啦
3. 饮食偏甜。其实刚工作我是很不喜欢这种饮食的，但是在外面吃饭是在不能避免，太淡的又真的让人没食欲，现在已经堕落到自己做菜都会放点糖了，之前在饮食里面已经注意减少了，之后继续加油
4. 喜食草酸含量高的食物。这个大家可以自己搜索，我就爱吃豆腐、花生、红薯、橘子。
5. 喝水少。我相对很多同事来说算是喝的挺多了。之后每天至少喝 2000 毫升水吧

在得结石后，除了去医院体外碎石，我更建议在它尚小的时候通过多喝水和多运动让他自己出来。最后说几点我对结石的认识：

1. 结石病很常见。我对住院病人的不负责的统计，大概 1/3 的病人都是结石。
2. 我并没有找到权威的高危人群和年轻的论文。以我对医院病友们的观察和交流，30-40 岁，55-65 岁这 2 个年龄段居多。相对来说女性得结石的要少很多，但是几率这种东西放在个人生身上就是 0% 和 100%，只不过年轻的关注小一些，随着年龄增大要越来越关注。
3. 结石分很多种，大部分是肾结石和输尿管结石。
4. 结石发作很痛。有过结石的同学可以留言说说感受，相对于一些病友刀割般疼、哭天喊地、直不起腰的感受，我的那种疼还没到痛不欲生的地步，只是当天下午等门诊时疼的跪在地上了。不过我还是建议大家不要体验这种感觉比较幸福。

就写到这里吧，感谢大家看完。

原文: 消失的结石

按照 Python3.7 的发布时间表，明天 Python 3.7.0 就发布了，最近各大开源项目都在做 3.7 相关的调整，之后我还会写文章更详细的介绍 Python 3.7 都带来了什么，敬请关注！Python 3.7 是一个比较中庸的版本，我比较关注的是 PEP 557 和 本文要提到的 PEP 562 。

PEP557 是 Data Classes，之前我已经在 attrs 和 Python3.7 的 dataclasses 里面专门介绍了。

PEP 562 主要做的是什么呢？

Customization of Access to Module Attributes

就是能在模块下定义getattr和dir方法，实现定制访问模块属性了。有什么用呢？其实官网已经给出了答案：

1. 弃用某些属性 / 函数
2. 懒加载 (lazy loading)

getattr让模块属性的访问非常灵活，我分别举几个例子：

弃用某些属性 / 函数时

有时候会修改一些函数或者属性，会写新的版本，旧版本的在一段时间之后会弃用。在大型项目中调用者有很多，不了解业务挨处修改成本很高，通常会在旧版本的函数中加入 DeprecationWarning，有 3 个问题：

1. 使用新的属性是没法提示 DeprecationWarning，只能在模块级别加 warn
2. 如果找不到属性 / 函数直接抛错误了，不能做特殊处理
3. 模块下弃用的函数多了，只能在每个函数内部加入 warn，再执行新函数逻辑

而 Python 3.7 就没这个问题了：

# lib.py

import warnings

warnings.filterwarnings('default')  # Python 3.2开始默认会隐藏DeprecationWarning


def new_function(arg, other):
    print('plz use me!')


_deprecated_map = {
    'old_function': new_function
}


def __getattr__(name):
    if name in _deprecated_map:
        switch_to = _deprecated_map[name]
        warnings.warn(f'{name} is deprecated. Switch to {__name__}.{switch_to.__name__}.',
             DeprecationWarning)
        return switch_to
    raise AttributeError(f"module {__name__} has no attribute {name}")

看一下效果吧：

>>> from lib import old_function
/Users/dongwm/test/lib.py:18: DeprecationWarning: old_function is deprecated. Switch to lib.new_function.
  DeprecationWarning)
>>> old_function
<function new_function at 0x10ad30f28>
>>> old_function(1, 2)
plz use me!

懒加载

懒加载是指从一个数据对象通过方法获得里面的一个属性对象时，这个对应对象实际并没有随其父数据对象创建时一起保存在运行空间中，而是在其读取方法第一次被调用时才从其他数据源中加载到运行空间中，这样可以避免过早地导入过大的数据对象但并没有使用的空间占用浪费。

简单地说，按需才加载。这是一种设计模式。

Python3.7 之前想要 import 模块成功，就得在模块里面把相关属性 / 函数 / 类等都准备好，其实 import 模块时候是很重的，现在可以通过 PEP 562，能够极大的提升 import 的效率，尤其是导入了很重的逻辑。就如 PEP 中提的例子：

# lib/__init__.py

import importlib

__all__ = ['submod', ...]

def __getattr__(name):
    if name in __all__:
        return importlib.import_module("." + name, __name__)
    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

# lib/submod.py

print("Submodule loaded")


class HeavyClass:
    ...

# main.py

import lib
lib.submodule.HeavyClass  # prints "Submodule loaded"

可以看到，import lib 的时候，HeavyClass 还没有没有加载的，当第一次使用 lib.submodule 的时候才会加载。

在标准库里面也有应用，比如 bpo-32596 中对 concurrent.futures 模块的修改：

def __dir__():
    return __all__ + ('__author__', '__doc__')


def __getattr__(name):
    global ProcessPoolExecutor, ThreadPoolExecutor

    if name == 'ProcessPoolExecutor':
        from .process import ProcessPoolExecutor as pe
        ProcessPoolExecutor = pe
        return pe

    if name == 'ThreadPoolExecutor':
        from .thread import ThreadPoolExecutor as te
        ThreadPoolExecutor = te
        return te

    raise AttributeError(f"module {__name__} has no attribute {name}")

这样还可以让 import asyncio 时可以快 15%。

原文: Python 3.7 中的 PEP 562

一直想写一篇介绍 attrs 的文章，但是最近几个月忙于做 爱湃森课程 实在抽不出空来做，最近感觉找到节奏了，还是稳步向前走了，这个周末就硬挤了一下午写写，要不感觉对不起订阅专栏的同学们。

在国内我没见过有同学说这 2 个东西，它们是什么，又有什么关联呢？别着急，先铺垫一下他俩出现的背景。

痛点

写多了 Python，尤其是开发和微信的项目比较大的时候，你可能和我一样感觉写 Python 的类很累。怎么累呢？举个例子，现在有个商品类，init是这么写的：

class Product(object):
    def __init__(self, id, author_id, category_id, brand_id, spu_id, 
                 title, item_id, n_comments, creation_time, update_time, 
                 source='', parent_id=0, ancestor_id=0): 
        self.id = id
        self.author_id = author_id
        self.category_id = category_id
        ...

问题 1：特点是初始化参数很多，每一个都需要 self.xx = xx 这样往实例上赋值。我印象见过一个类有 30 多个参数，这个init方法下光是赋值就占了一屏多...

再说问题 2，如果不定义repr方法，打印类对象的方式很不友好，大概是这样的：

In : p
Out: <test.Product at 0x10ba6a320>

定义时参数太多，一般按需要挑几个露出来:

def __repr__(self):
    return '{}(id={}, author_id={}, category_id={}, brand_id={})'.format(
        self.__class__.__name__, self.id, self.author_id, self.category_id, 
        self.brand_id)

这样再看类对象就友好了：

In : p
Out: Product(id=1, author_id=100001, category_id=2003, brand_id=20)

但是每个类都需要手动的去写 repr！

接着说问题 3，对象比较，有时候需要判断 2 个对象是否相等甚至大小（例如用于展示顺序）：

def __eq__(self, other):
    if not isinstance(other, self.__class__):
        return NotImplemented
    return (self.id, self.author_id, self.category_id, self.brand_id) == (
        other.id, other.author_id, other.category_id, other.brand_id)
def __lt__(self, other):
    if not isinstance(other, self.__class__):
        return NotImplemented
    return (self.id, self.author_id, self.category_id, self.brand_id) < (
        other.id, other.author_id, other.category_id, other.brand_id)

如果对比的更全面不用所有 gt、gte、lte 都写出来，用 functools.total_ordering 这样就够了：

from functools import total_ordering


@total_ordering
class Product(object):
   ...

然后是问题 4。有些场景下希望对对象去重，可以添加hash:

def __hash__(self):
    return hash((self.id, self.author_id, self.category_id, self.brand_id))

这样就不需要对一大堆的对象挨个比较去重了，直接用集合就可以了：

In : p1 = Product(1, 100001, 2003, 20, 1002393002, '这是一个测试商品1', 2000001, 100, None, 1)

In : p2 = Product(1, 100001, 2003, 20, 1002393002, '这是一个测试商品2', 2000001, 100, None, 2)

In : {p1, p2}
Out: {Product(id=1, author_id=100001, category_id=2003, brand_id=20)}

可以看到集合只返回了一个对象，另外一个被去掉了。

最后是问题 5。我很喜欢给类写一个 to_dict、to_json 或者 as_dict 这样的方法，把类里面的属性打包成一个字典返回。基本都是每个类都要写一遍它：

def to_dict(self):
    return {
        'id': self.id,
        'author_id': self.author_id,
        'category_id': self.category_id,
        ...
    }

当然没有特殊的理由，可以直接使用 vars (self) 获得， 上面这种键值对指定的方式会更精准，只导出想导出的部分，举个特殊的理由吧：

def to_dict(self):
    self._a = 1
    return vars(self)

会把_a 也包含在返回的结果中，然而它并不应该被导出，所以不适合 vars 函数。

到这里，我们停下来想想，self.id、self.author_id、self.category_id 这些分别写了几次？

那有没有一种方法，可以在创建类的时候自动给类加上这些东西，把开发者解脱出来呢？这就是我们今天介绍的 attrs 和 Python 3.7 标准库里面将要加的 dataclasses 模块做的事情，而且它们能做的会更多。

attrs

attrs 是 Python 核心开发 Hynek Schlawack 设计并实现的一个项目，它就是解决上述痛点而生的，上述类，使用 attrs 这样写:

import attr


@attr.s(hash=True)
class Product(object):
    id = attr.ib()
    author_id = attr.ib()
    brand_id = attr.ib()
    spu_id = attr.ib()
    title = attr.ib(repr=False, cmp=False, hash=False)
    item_id = attr.ib(repr=False, cmp=False, hash=False)
    n_comments = attr.ib(repr=False, cmp=False, hash=False)
    creation_time = attr.ib(repr=False, cmp=False, hash=False)
    update_time = attr.ib(repr=False, cmp=False, hash=False)
    source = attr.ib(default='', repr=False, cmp=False, hash=False)
    parent_id = attr.ib(default=0, repr=False, cmp=False, hash=False)
    ancestor_id = attr.ib(default=0, repr=False, cmp=False, hash=False)

这就可以了，上面说的那些 dunder 方法 (双下划线开头和结尾的方法) 都不用写了:

In : p1 = Product(1, 100001, 2003, 20, 1002393002, '这是一个测试商品1', 2000001, 100, None, 1)

In : p2 = Product(1, 100001, 2003, 20, 1002393002, '这是一个测试商品2', 2000001, 100, None, 2)

In : p3 = Product(3, 100001, 2003, 20, 1002393002, '这是一个测试商品3', 2000001, 100, None, 3)

In : p1
Out: Product(id=1, author_id=100001, brand_id=2003, spu_id=20)

In : p1 == p2
Out: True

In : p1 > p3
Out: False

In : {p1, p2, p3}
Out:
{Product(id=1, author_id=100001, brand_id=2003, spu_id=20),
 Product(id=3, author_id=100001, brand_id=2003, spu_id=20)}

In : attr.asdict(p1)
Out:
{'ancestor_id': 0,
 'author_id': 100001,
 'brand_id': 2003,
 'creation_time': 100,
 'id': 1,
 'item_id': '这是一个测试商品1',
 'n_comments': 2000001,
 'parent_id': 0,
 'source': 1,
 'spu_id': 20,
 'title': 1002393002,
 'update_time': None}

In : attr.asdict(p1, filter=lambda a, v: a.name in ('id', 'title', 'author_id'))
Out: {'author_id': 100001, 'id': 1, 'title': 1002393002}

是不是清爽直观？

当然， 我这个例子中对属性的要求比较多，所以不同属性的参数比较长。看这个类的定义的方式是不是有点像 ORM？对象和属性的关系直观，不参与类中代码逻辑。

有兴趣的可以看[Kenneth Reitz、Łukasz Langa、Glyph Lefkowitz 等人对项目的评价] ( http://www.attrs.org/en/stable/index.html#testimonials)。 。)

除此之外，attrs 还支持多种高级用法，如字段类型验证、自动类型转化、属性值不可变（Immutability）、类型注解等等 ，我列 3 个我觉得非常有用的吧

字段类型验证

业务代码中经验会对对象属性的类型和内容验证，attrs 也提供了验证支持。验证有 2 种方案：

1. 装饰器

>>> @attr.s
... class C(object):
...     x = attr.ib()
...     @x.validator
...     def check(self, attribute, value):
...         if value > 42:
...             raise ValueError("x must be smaller or equal to 42")
>>> C(42)
C(x=42)
>>> C(43)
Traceback (most recent call last):
   ...
ValueError: x must be smaller or equal to 42

1. 属性参数：

>>> def x_smaller_than_y(instance, attribute, value):
...     if value >= instance.y:
...         raise ValueError("'x' has to be smaller than 'y'!")
>>> @attr.s
... class C(object):
...     x = attr.ib(validator=[attr.validators.instance_of(int),
...                            x_smaller_than_y])
...     y = attr.ib()
>>> C(x=3, y=4)
C(x=3, y=4)
>>> C(x=4, y=3)
Traceback (most recent call last):
   ...
ValueError: 'x' has to be smaller than 'y'!

属性类型转化

Python 不会检查传入的值的类型，类型错误很容易发生，attrs 支持自动的类型转化：

>>> @attr.s
... class C(object):
...     x = attr.ib(converter=int)
>>> o = C("1")
>>> o.x
1

包含元数据

属性还可以包含元数据！这个真的非常有用，这个属性的值就不仅仅是一个值了，带上元数据的值非常灵活也更有意义，这样就不需要额外的把属性需要的元数据独立存储起来了。

>>> @attr.s
... class C(object):
...    x = attr.ib(metadata={'my_metadata': 1})
>>> attr.fields(C).x.metadata
mappingproxy({'my_metadata': 1})
>>> attr.fields(C).x.metadata['my_metadata']
1

通过上面支持的几个功能可以看出作者做项目就是基于实际工作痛点出发的。

dataclasses 模块

在 Python 3.7 里面会添加一个新的模块 dataclasses ，它基于 PEP 557 ，Python 3.6 可以通过 pip 下载安装使用:

pip install dataclasses

解决如上痛点，把 Product 类改成这样：

from datetime import datetime
from dataclasses import dataclass, field


@dataclass(hash=True, order=True)
class Product(object):
    id: int
    author_id: int
    brand_id: int
    spu_id: int
    title: str = field(hash=False, repr=False, compare=False)
    item_id = int = field(hash=False, repr=False, compare=False)
    n_comments = int = field(hash=False, repr=False, compare=False)
    creation_time: datetime = field(default=None, repr=False, compare=False,hash=False)
    update_time: datetime = field(default=None, repr=False, compare=False, hash=False)
    source: str = field(default='', repr=False, compare=False, hash=False)
    parent_id: int = field(default=0, repr=False, compare=False, hash=False)
    ancestor_id: int = field(default=0, repr=False, compare=False, hash=False)

先验证一下：

In : p1 = Product(1, 100001, 2003, 20, 1002393002, '这是一个测试商品1', 2000001, 100, None, 1)

In : p2 = Product(1, 100001, 2003, 20, 1002393002, '这是一个测试商品2', 2000001, 100, None, 2)

In : p3 = Product(3, 100001, 2003, 20, 1002393002, '这是一个测试商品3', 2000001, 100, None, 3)

In : p1
Out: Product(id=1, author_id=100001, brand_id=2003, spu_id=20)

In : p1 == p2
Out: True

In : p1 > p3
Out: False

In : {p1, p2, p3}
Out:
{Product(id=1, author_id=100001, brand_id=2003, spu_id=20),
 Product(id=3, author_id=100001, brand_id=2003, spu_id=20)}

In : from dataclasses import asdict

In : asdict(p1)
Out:
{'ancestor_id': 1,
 'author_id': 100001,
 'brand_id': 2003,
 'creation_time': '这是一个测试商品1',
 'id': 1,
 'parent_id': None,
 'source': 100,
 'spu_id': 20,
 'title': 1002393002,
 'update_time': 2000001}

dataclasses.asdict 不能过滤返回属性。但是总体满足需求。但是，你有没有发现什么不对？

attrs 和 dataclasses

虽然 2 种方案写的代码确实有些差别，但有木有觉得它俩很像？其实 attrs 的诞生远早于 dataclasses， dataclasses 更像是在借鉴。dataclasses 可以看做是一个强制类型注解，功能是 attrs 的子集。那么为什么不把 attrs 放入标准库，而是 Python 3.7 加入一个阉割版的 attrs 呢？

Glyph Lefkowitz 犀利的写了标题为 why not just attrs? 的 issue，我打开这个 issue 没往下看的时候，猜测是「由于 attrs 兼容 Python3.6，包含 Python2.7 的版本，进入标准库必然是一次卸掉包袱的重构，attrs 作者不同意往这个方向发展？」，翻了下讨论发现不是这样的。

这个 issue 很有意思，多个 Python 开发都参与进来了，最后 Gvanrossum 结束了讨论，明确表达不同意 attrs 进入标准库，Donald Stufft 也直接问了为啥？Gvanrossum 虽然解释了下，但是我还是觉得这算是「仁慈的独裁者」中的「独裁」部分的体现吧，Python 社区的态度一直是不太开放。包含在 PEP 557 下 解释为什么不用 attrs ，也完全说服不了我。

我站 attrs，向大家推荐！ 不仅是由于 attrs 兼容之前的 Python 版本，而是 attrs 是真的站在开发者的角度上添加功能支持，最后相信 attrs 会走的更远。

参考文章

1. http://www.attrs.org/en/stable/index.html
2. https://glyph.twistedmatrix.com/2016/08/attrs.html
3. https://www.python.org/dev/peps/pep-0557/

原文: attrs 和 Python3.7 的 dataclasses

前言

「如何学习编程」每个人都有自己的答案，在我初学 Python 的时候，我就非常关注大神们的学习方式和成长之路。工作这么些年过来，我发现大家入门和学习的共同点非常统一：读书、看源码、高频率的实践和动手，对于现在的同学还可以选择看视频。

在我的印象里面，大神 TJ Holowaychuk 的学习方法让我记忆深刻，大概 4-5 年前我看过一个介绍，但是找不到印象里的那篇了，只找到了这篇 TJ Holowaychuk 是怎样学习编程的？ 。TJ 的学习方法很特别：

也不读书，从不去听课，我就是去阅读别人的代码，并搞清楚那些代码是如何工作的。

而《Python 3 学习笔记（上卷）》作者雨痕在我印象里面就是这样通过阅读 CPython 源代码来学习 Python 的。

qyuhen/book

雨痕前辈从 1996 年开始从事计算机软件开发工作，从 2006 年接触 Python，他的 qyuhen/book 在 2013 年的时候就已经非常知名了。这个项目下是除了 Python 笔记，还有 Go，C 方面的学习笔记。

第一次阅读《Python 学习笔记》就被它的内容吸引，虽然只是作者的学习笔记，但是依然不影响对于学习 Python 的开发者的意义，我觉得这个笔记有 2 个显著的特点：

1. 从解释器和 CPython 源码实现的角度剖析语言语法
2. 通过在交互环境中的实验去证明和验证细节，获得结论

可以说这本书对 13 年的我来说，有很大的帮助。当然这个笔记里面还有一些有意思的点，我在 14 年的 Python 高级编程 分享中 PPT 一上来就引用了这个笔记中提到的怎么让 Python 支持 end:

__builtins__.end = None

def test(x):
    if x > 0:
        print "a"
    else:
        print "b"
    end
end


def main():
    test(1)
    print('I can use end!')
end

嗯，这不是 ruby。其实能这么写的根本原因就是 end 被解释成了 None，写成什么都可以：

__builtins__.endif = None

def test(x):
    if x > 0:
        return True
    endif

test(1)

之后雨痕老师的 《Go 语言学习笔记》 出版了，但是《Python 学习笔记》却没有动静，我既有失望也满怀期待，想必没有考虑出版它是由于这个笔记是针对 Python2.7 的。

但是不要紧，《Python 3 学习笔记（上卷）》来了。

荐书

关注我的同学应该都知道我是不愿意参与荐书的，我得对订阅者负责。我没看过的、觉得不好的书我是不可能推荐给别人的。

目前我正式的荐书只有 《流畅的 Python》 和平时在群里说到的 《python 编程 从入门到实践》 ，《Python 3 学习笔记（上卷）》是我推荐的第三本书。节前就收到了样书，刚刚读完，给大家分享一下读后感。

本书的特点

1. 书中内容基于目前最新的 Python 3.6 版本，书中提到的一些最新的 Python 内容还很少有中文书或者博客来介绍。在 2018 年这个节点，如果一本新书还在讲 Python 2，反正我是不会买了。
2. 同样是从解释器和 CPython 源码实现的角度剖析语言语法。市面上大部分的教程都是在告诉你应该怎么用，但是背后隐藏的细节和原理却很少提及，这本书对这些并不避讳，而更像是想弄清楚解释器执行的流程和细节。尤其是在「解释器」章节里面除了从源码上分析 GIL，还有内存分配、垃圾回收和 Python 执行过程的方面的内容。
3. 配图丰富、简单易懂。同作为图书作者，我很了解做配图是一件很耗时辛苦的事情，既要对配图的内容理解非常深刻，也要让它直观好懂是很难的，这本书这点做的就不错。
4. 通过在交互环境中的实验去证明和验证细节，获得结论。这是我非常喜欢的方式，作为一个读者用这样的方式学习知识是很轻松愉快的

5. 概念定义深刻准确。雨痕老师的编程经验非常丰富，对 Python 也很熟悉，对一些知识点的定义和理解非常好。我举 2 个例子： 1.「包和模块」。有多少人不能清晰区分他俩？我看到很多同学用这 2 个词的时候很随意，这本书里面是这么说的： 模块 (module) 是顶层代码组织单元，其提供大粒度的封装和复用... 如果说模块用于组织代码，那么包就是用来组织模块的...

   我的感觉是总结非常到位。

   借助生成器切换执行功能，改善程序的结构设计。我举书中列出的 2 个例子，第一个是生产消息模型：

def consumer():
    while True:
        v = yield
        print(f'consume: {v}')


def producer(c):
    for i in range(10, 13):
        c.send(i)



c = consumer()
c.send(None)

producer(c)
c.close()

当然作者也提到如果有多个消费者或者数据处理时间较长，还是建议使用专业的并发方案。第二个是消除回调。我们先看看异步回调的模式：

import time
import threading


def target(request, callback):
    s = time.time()
    request()
    time.sleep(2)
    callback(f'done: {time.time() -s }')


def request():
    print('start')

def callback(x):
    print(x)


def service(request, callback):
    threading.Thread(target=target, args=(request, callback)).start()

我一直不喜欢回调，这种接口设计的方式会让代码和逻辑分散开，维护性很差。如果使用生成器怎么做呢？

def request():
    print('start')
    x = yield
    print(x)


def target(fn):
    try:
        s = time.time()
        g = fn()
        g.send(None)

        time.sleep(2)
        g.send(f'done: {time.time() -s }')
    except StopIteration:
        pass


def service(fn):
    threading.Thread(target=target, args=(fn,)).start()

service(request)

这样就不需要callback性质的额外参数了，通过yield让程序逻辑看起来是串行的。

我要强调一下：这本书并不是适合入门，它假定读者已经有一定的编程和 Python 基础。所以更适合已经熟悉 Python 语言语法，使用 Python 写过程序的开发者，如果你正准备迁移 Python 2 的代码到 Python 3.6 这本书就更值得看一看了。

在上个月发布的 《爱湃森 2017 年度 Python 榜单》 中，我也把这本书放到了 2018 年最值得期待的国内出版的 Python 书籍 的第二位（那会我还没拿到样书），现在看来这本书也物超所值，对我这种 Python 老手来说，看书获取新知识的几率已经不高，但是从这本书里面我还是收获了很多。我举几个印象深刻的例子：

1. 池化。之前没了解过，就是相同名字可能会重复出现在不同的名字空间里，就有必要共享实例，这样节约内存，也省去了创建新实例的开销，所以 Python 实现了字符串池。
2. SimpleNamespace。之前我想快速的构建一个结构化的实例会用 namedtuple，但是缺点是它构建出来的是一个类型：

In [5]: Point = namedtuple('Point', ['x', 'y'])  # 构建出来的是一个类，而且传递参数的效果也不直观，field_names需要是一个列表或者空格分割的字符串，不方便
In [6]: p = Point(1, 2)  # 我还得实例化一下Point才能用
In [7]: p.x, p.y
Out[7]: (1, 2)

这样不方面，SimpleNamespace 就可以直接创建实例：

In [8]: from types import SimpleNamespace
In [9]: p = SimpleNamespace(x=1, y=2)
In [10]: p.x, p.y
Out[10]: (1, 2)

这样用起来就方便多了。

1. 自定义异常类的名字。我以前自定义异常的名字比较随意，XyzException 或者 XyzError 通常有点看心情或者仿之前名字格式，这本书这样说的「内置异常多以 Error 结尾，但建议以 Exception、Error 后缀区分可修复异常和不可修复异常」，我觉得说得对...

上述这几点算是我的读书笔记，详细的还得看书中原文哦。

希望国内能出现越来越多的好书！有能力有想法的同学，可以私信我帮你联系出版社哟

赠书

我向电子工业出版社谋了 5 本《Python-3 学习笔记（上卷）》福利给大家。这次在移动端的抽奖用「抽奖助手」小程序，关注本公众号之后，长按下图，在弹出框中「选择识别图中的小程序码」进入抽奖页面即可。

原文: 推荐 + 赠书 《Python 3学习笔记（上卷）》

前言

以前在我的 PPT python 高级编程 也提到了一些关于 ipython 的用法。今天继续由浅入深的看看 ipython, 本文作为读者的你已经知道 ipython 并且用了一段时间了.

%run

这是一个 magic 命令，能把你的脚本里面的代码运行，并且把对应的运行结果存入 ipython 的环境变量中:

$cat t.py
# coding=utf-8
l = range(5)

$ipython
In [1]: %run t.py # `%`可加可不加

In [2]: l # 这个l本来是t.py里面的变量, 这里直接可以使用了
Out[2]: [0, 1, 2, 3, 4]

alias

In [3]: %alias largest ls -1sSh | grep %s
In [4]: largest to
total 42M
 20K tokenize.py
 16K tokenize.pyc
8.0K story.html
4.0K autopep8
4.0K autopep8.bak
4.0K story_layout.html

PS 别名需要存储的，否则重启 ipython 就不存在了:

In [5]: %store largest
Alias stored: largest (ls -1sSh | grep %s)

下次进入的时候 % store -r

bookmark - 对目录做别名

In [2]: %pwd
Out[2]: u'/home/vagrant'

In [3]: %bookmark dongxi ~/shire/dongxi

In [4]: %cd dongxi
/home/vagrant/shire/dongxi_code

In [5]: %pwd
Out[5]: u'/home/vagrant/shire/dongxi_code'

ipcluster - 并行计算

其实 ipython 提供的方便的并行计算的功能。先回答 ipython 做并行计算的特点:

1.

$wget http://www.gutenberg.org/files/27287/27287-0.txt

第一个版本是直接的，大家习惯的用法.

In [1]: import re

In [2]: import io

In [3]: non_word = re.compile(r'[\W\d]+', re.UNICODE)

In [4]: common_words = {
   ...: 'the','of','and','in','to','a','is','it','that','which','as','on','by',
   ...: 'be','this','with','are','from','will','at','you','not','for','no','have',
   ...: 'i','or','if','his','its','they','but','their','one','all','he','when',
   ...: 'than','so','these','them','may','see','other','was','has','an','there',
   ...: 'more','we','footnote', 'who', 'had', 'been',  'she', 'do', 'what',
   ...: 'her', 'him', 'my', 'me', 'would', 'could', 'said', 'am', 'were', 'very',
   ...: 'your', 'did', 'not',
   ...: }

In [5]: def yield_words(filename):
   ...:     import io
   ...:     with io.open(filename, encoding='latin-1') as f:
   ...:         for line in f:
   ...:             for word in line.split():
   ...:                 word = non_word.sub('', word.lower())
   ...:                 if word and word not in common_words:
   ...:                     yield word
   ...:

In [6]: def word_count(filename):
   ...:     word_iterator = yield_words(filename)
   ...:     counts = {}
   ...:     counts = defaultdict(int)
   ...:     while True:
   ...:         try:
   ...:             word = next(word_iterator)
   ...:         except StopIteration:
   ...:             break
   ...:         else:
   ...:             counts[word] += 1
   ...:     return counts
   ...:

In [6]: from collections import defaultdict # 脑残了 忘记放进去了..
In [7]: %time counts = word_count(filename)
CPU times: user 88.5 ms, sys: 2.48 ms, total: 91 ms
Wall time: 89.3 ms

现在用 ipython 来跑一下:

ipcluster start -n 2 # 好吧, 我的Mac是双核的

先讲下 ipython 并行计算的用法:

In [1]: from IPython.parallel import Client # import之后才能用%px*的magic

In [2]: rc = Client()

In [3]: rc.ids # 因为我启动了2个进程
Out[3]: [0, 1]

In [4]: %autopx # 如果不自动 每句都需要: `%px xxx`
%autopx enabled

In [5]: import os # 这里没autopx的话 需要: `%px import os`

In [6]: print os.getpid() # 2个进程的pid
[stdout:0] 62638
[stdout:1] 62636

In [7]: %pxconfig --targets 1 # 在autopx下 这个magic不可用
[stderr:0] ERROR: Line magic function `%pxconfig` not found.
[stderr:1] ERROR: Line magic function `%pxconfig` not found.

In [8]: %autopx # 再执行一次就会关闭autopx
%autopx disabled

In [10]: %pxconfig --targets 1 # 指定目标对象, 这样下面执行的代码就会只在第2个进程下运行

In [11]: %%px --noblock # 其实就是执行一段非阻塞的代码
   ....: import time
   ....: time.sleep(1)
   ....: os.getpid()
   ....:
Out[11]: <AsyncResult: execute>

In [12]: %pxresult # 看 只返回了第二个进程的pid
Out[1:21]: 62636

In [13]: v = rc[:] # 使用全部的进程, ipython可以细粒度的控制那个engine执行的内容

In [14]: with v.sync_imports(): # 每个进程都导入time模块
   ....:     import time
   ....:
importing time on engine(s)

In [15]: def f(x):
   ....:     time.sleep(1)
   ....:     return x * x
   ....:

In [16]: v.map_sync(f, range(10)) # 同步的执行

Out[16]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

In [17]: r = v.map(f, range(10)) # 异步的执行

In [18]: r.ready(), r.elapsed # celery的用法
Out[18]: (True, 5.87735)

In [19]: r.get() # 获得执行的结果
Out[19]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

入正题:

In [20]: def split_text(filename):
....:    text = open(filename).read()
....:    lines = text.splitlines()
....:    nlines = len(lines)
....:    n = 10
....:    block = nlines//n
....:    for i in range(n):
....:        chunk = lines[i*block:(i+1)*(block)]
....:        with open('count_file%i.txt' % i, 'w') as f:
....:            f.write('\n'.join(chunk))
....:    cwd = os.path.abspath(os.getcwd())
....:    fnames = [ os.path.join(cwd, 'count_file%i.txt' % i) for i in range(n)] # 不用glob是为了精准
....:    return fnames

In [21]: from IPython import parallel

In [22]: rc = parallel.Client()

In [23]: view = rc.load_balanced_view()

In [24]: v = rc[:]

In [25]: v.push(dict(
   ....:     non_word=non_word,
   ....:     yield_words=yield_words,
   ....:     common_words=common_words
   ....: ))
Out[25]: <AsyncResult: _push>

In [26]: fnames = split_text(filename)

In [27]: def count_parallel():
   .....:     pcounts = view.map(word_count, fnames)
   .....:     counts = defaultdict(int)
   .....:     for pcount in pcounts.get():
   .....:         for k, v in pcount.iteritems():
   .....:             counts[k] += v
   .....:     return counts, pcounts
   .....:

In [28]: %time counts, pcounts = count_parallel() # 这个时间包含了我再聚合的时间
CPU times: user 47.6 ms, sys: 6.67 ms, total: 54.3 ms # 是不是比直接运行少了很多时间?
Wall time: 106 ms # 这个时间是

In [29]: pcounts.elapsed, pcounts.serial_time, pcounts.wall_time
Out[29]: (0.104384, 0.13980499999999998, 0.104384)

更多地关于并行计算请看这里: Parallel Computing with IPython

原文: ipython的一些高级用法(一)