Python import hook

转自http://blog.konghy.cn/2016/10/25/python-import-hook/，这里有好多好文章

import hook 一般被译为 探针。咱们能够认为每当导入模块的时候，所触发的操做就是 import hook。使用 import 的 hook 机制可让咱们作不少事情，好比加载网络上的模块，在导入模块时对模块进行修改，自动安装缺失模块，上传审计信息，延迟加载等等。

理解 import hook 须要先了解 Python 导入模块的过程。

1、 导入过程

Python 一般使用 import 语句来实现类库的引用，固然内建的 __import__() 函数等都能实现。 import 语句负责作两件事：

• 查找模块
• 加载模块到当前名字空间

那么，一个模块的导入过程大体能够分为三个步骤：搜索、加载 和 名字绑定。

1.1 搜索

搜索是整个导入过程的核心，也是最为复杂的一步。这个过程主要是完成查找要引入模块的功能，查找的过程以下：

• 一、在缓存 sys.modules 中查找要导入的模块，若找到则直接返回该模块对象
• 二、若是在 sys.modules 中没有找到相应模块的缓存，则顺序搜索 sys.meta_path，逐个借助其中的 finder 来查找模块，若找到则加载后返回相应模块对象。
• 三、若是以上步骤都没找到该模块，则执行默认导入。即若是模块在一个包中（如import a.b），则以 a.__path__ 为搜索路径进行查找；若是模块不在一个包中（如import a），则以 sys.path 为搜索路径进行查找。
• 四、若是都未找到，则抛出 ImportError 异常。

查找过程也会检查⼀些隐式的 finder 对象，不一样的 Python 实现有不一样的隐式finder，可是都会有 sys.path_hooks, sys.path_importer_cache 以及sys.path。

1.2 加载

对于搜索到的模块，若是在缓存 sys.modules 中则直接返回模块对象，不然就须要加载模块以建立一个模块对象。加载是对模块的初始化处理，包括如下步骤：

• 设置属性：包括 __name__、__file__、__package__、__loader__ 和 __path__ 等
• 编译源码：将模块文件（对于包，则是其对应的 __init__.py 文件）编译为字节码（*.pyc 或者 *.pyo），若是字节码文件已存在且仍然是最新的，则不从新编译
• 执行字节码：执行编译生成的字节码（即模块文件或 __init__.py 文件中的语句）

须要注意的是，加载不仅是发生在导入时，还能够发生在 reload 时。

1.3 名字绑定

加载完模块后，做为最后一步，import 语句会为 导入的对象 绑定名字，并把这些名字加入到当前的名字空间中。其中，导入的对象 根据导入语句的不一样有所差别：

• 若是导入语句为 import obj，则对象 obj 能够是包或者模块
• 若是导入语句为 from package import obj，则对象 obj 能够是 package 的子包、package 的属性或者 package 的子模块
• 若是导入语句为 from module import obj，则对象 obj 只能是 module 的属性

2、模块缓存

进行搜索时，搜索的第一个地方是即是 sys.modules。sys.modules 是一个字典，键字为模块名，键值为模块对象。它包含了从 Python 开始运行起，被导入的全部模块的一个缓存，包括中间路径。因此，假如 foo.bar.baz 前期已被导入，那么，sys.modules 将包含进入 foo，foo.bar 和 foo.bar.baz的入口。每一个键都有本身的数值，都有对应的模块对象。也就是说，若是导入 foo.bar.baz 则整个层次结构下的模块都被加载到了内存。

能够删除 sys.modules 中对应的的键或者将值设置为 None 来使缓存无效。

当启动 Python 解释器时，打印一下 sys.modules 中的 key：

>>> import sys
>>> sys.modules.keys()
['copy_reg', 'sre_compile', '_sre', 'encodings', 'site', '__builtin__', 'sysconfig', '__main__', 'encodings.encodings', 'abc', 'posixpath', '_weakrefset', 'errno', 'encodings.codecs', 'sre_constants', 're', '_abcoll', 'types', '_codecs', 'encodings.__builtin__', '_warnings', 'genericpath', 'stat', 'zipimport', '_sysconfigdata', 'warnings', 'UserDict', 'encodings.utf_8', 'sys', 'codecs', 'readline', '_sysconfigdata_nd', 'os.path', 'sitecustomize', 'signal', 'traceback', 'linecache', 'posix', 'encodings.aliases', 'exceptions', 'sre_parse', 'keyrings', 'os', '_weakref']

能够看出一些模块已经被解释器导入，可是咱们却不能直接使用这些模块。这是由于这些模块尚未被绑定到当前名字空间，仍然须要执行 import 语句才能完成名字绑定。

3、查找器和加载器

在搜索过程当中咱们提到 sys.meta_path 中保存了一些 finder 对象。在 Python 查找的时候，若是在 sys.modules 中没有查找到，就会依次调用 sys.meta_path 中的 finder 对象，即调用导入协议来查找和加载模块。导入协议包含两个概念性的对象，查找器（loader） 和 加载器（loader）。sys.meta_path 在任何默认查找程序或 sys.path 以前搜索。默认的状况下，在 Python2 中 sys.meta_path 是一个空列表，并无任何 finder 对象；而在 Python3 中则在 Python 中则默认包含三个查找器：第一个知道如何定位内置模块，第二个知道如何定位冻结模块，第三个搜索模块的导入路径：

[<class '_frozen_importlib.BuiltinImporter'>, <class '_frozen_importlib.FrozenImporter'>, <class '_frozen_importlib.PathFinder'>]

在 Python 中，不只定义了 finder 和 loader 的概念，还定义了 importor 的概念：

• 查找器（finder）： 决定本身是否可以经过运用其所知的任何策略找到相应的模块。在 Python2 中，finder 对象必须实现 find_module() 方法，在 Python3 中必需要实现 find_module() 或者 find_loader（) 方法。若是 finder 能够查找到模块，则会返回一个 loader 对象(在 Python 3.4中，修改成返回一个模块分支module specs，加载器在导入中仍被使用，但几乎没有责任)，没有找到则返回 None。
• 加载器（loader）： 负责加载模块，它必须实现一个 load_module() 的方法
• 导入器（importer）： 实现了 finder 和 loader 这两个接口的对象称为导入器

咱们能够想 sys.meta_path 中添加一些自定义的加载器，来实如今加载模块时对模块进行修改。例如一个简单的例子，在每次加载模块时打印模块信息：

from __future__ import print_function
import sys

class Watcher(object):

    @classmethod
    def find_module(cls, name, path, target=None):
        print("Importing", name, path, target)
        return None

sys.meta_path.insert(0, Watcher)

import subprocess

输出结果：

Importing subprocess None None
Importing gc None None
Importing time None None
Importing select None None
Importing fcntl None None
Importing pickle None None
Importing marshal None None
Importing struct None None
Importing _struct None None
Importing org None None
Importing binascii None None
Importing cStringIO None None

4、导入钩子程序

Python 的导入机制被设计为可扩展的，其基础的运行机制即是 import hook（导入钩子程序）。Python 存在两种导入钩子程序的形态：一类是上文提到的 meta hook（元钩子程序）， 另外一类是 path hook（导入路径钩子程序）。

在其余任何导入程序运行以前，除了 sys.modules 缓存查找，在导入处理开始时调用元钩子程序。这就容许元钩子程序覆盖 sys.path 处理程序，冻结模块，或甚至内建模块。能够经过给 sys.meta_path 添加新的查找器对象来注册元钩子程序。

当相关路径项被冲突时，导入路径钩子程序做为 sys.path (或者 package.__path__) 处理程序的一部分被调用。能够经过给 sys.path_hooks 添加新的调用来注册导入路径钩子程序。

sys.path_hooks 是由可被调用的对象组成，它会顺序的检查以决定他们是否能够处理给定的 sys.path 的一项。每一个对象会使用 sys.path 项的路径来做为参数被调用。若是它不能处理该路径，就必须抛出 ImportError 异常，若是能够，则会返回一个 importer 对象。以后，不会再尝试其它的 sys.path_hooks 对象，即便前一个 importer 出错了。

经过 import hook 咱们能够根据需求来扩展 Python 的 import 机制。一个简单的使用导入钩子的实例，在 import 时判断库是否被安装，不然就自动安装：

from __future__ import print_function
import sys
import pip
from importlib import import_module


class AutoInstall(object):

    _loaded = set()

    @classmethod
    def find_module(cls, name, path, target=None):
        if path is None and name not in cls._loaded:
            cls._loaded.add(name)
            print("Installing", name)
            installed = pip.main(["install", name])
            if installed == 0:
                return import_module(name)
            else:    
                return None

sys.meta_path.append(AutoInstall)

Python 还提供了一些模块和函数，能够用来实现简单的 import hook，主要有一下几种：

• __import__: Python 的内置函数；
• imputil: Python 的 import 工具库，在 Python2.6 被声明废弃，Python3 中完全移除；
• imp: Python2 和 Python3 都存在的一个 import 库；
• importlib: Python3 中最新添加，backport 到 Python2.7，但只有很小的子集（只有一个 import_module 函数）。

5、site 模块

site 模块用于 python 程序启动的时候，作一些自定义的处理。在 Python 程序运行前，site 模块会自动导入，并按照以下顺序完成初始化工做:

• 将 sys.prefix 、sys.exec_prefix 和 lib/pythonX.Y/site-packages 合成 module 的 search path。加入sys.path。eg: /home/jay/env/tornado/lib/python2.7/site-packages
• 在添加的路径下寻找 pth 文件。 该文件中描述了添加到 sys.path 的子文件夹路径。
• import sitecustomize， sitecustomize 内部能够作任意的设置。
• import usercustomize， usercustomize 通常放在用户的 path 环境下， 如: /home/jay/.local/lib/python2.7/site-packages/usercustomize， 其内部能够作任意的设置。

site 模块的本质能够说是补充 sys.path 路径，协助解释器预配置第三方模块目录。因此能够设置特殊的 sitecustomize.py 或者 usercustomize.py 文件, 在 python 代码执行以前，添加 import hook。

6、导入搜索路径

Python 在 import 时会在系统中搜索模块或者包所在的位置，sys.path 变量中保存了全部可搜索的库路径，它是一个路径名的列表，其中的路径主要分为如下几部分：

• 程序主目录（默认定义）： 若是是以脚本方式启动的程序，则为启动脚本所在目录；若是在交互式解释器中，则为当前目录；
• PYTHONPATH目录（可选扩展）： 以 os.pathsep 分隔的多个目录名，即环境变量 os.environ['PYTHONPATH']（相似 shell 环境变量 PATH）；
• 标准库目录（默认定义）： Python 标准库所在目录（与安装目录有关）；
• .pth文件目录（可选扩展）： 以 “.pth” 为后缀的文件，其中列有一些目录名（每行一个目录名）。

所以若是想要添加库的搜索路径，能够有以下方法：

• 直接修改 sys.path 列表
• 使用 PYTHONPATH 扩展
• 使用 .pth 文件扩展

7、从新加载

关于 import，还有一点很是关键：加载只在第一次导入时发生。Python 这样设计的目的是由于加载是个代价高昂的操做。

一般状况下，若是模块没有被修改，这正是咱们想要的行为；但若是咱们修改了某个模块，重复导入不会从新加载该模块，从而没法起到更新模块的做用。有时候咱们但愿在 运行时（即不终止程序运行的同时），达到即时更新模块的目的，内建函数 reload() 提供了这种 从新加载 机制（在 Python3 中被挪到了 imp 模块下）。

关于 reload 与 import 的不一样：

• import 是语句，而 reload 是函数
• import 使用 模块名，而 reload 使用 模块对象（即已被import语句成功导入的模块）

从新加载 reload(module) 有如下几个特色：

• 会从新编译和执行模块文件中的顶层语句
• 会更新模块的名字空间（字典 M.__dict__）：覆盖相同的名字（旧的有，新的也有），保留缺失的名字（旧的有，新的没有），添加新增的名字（旧的没有，新的有）
• 对于由 import M 语句导入的模块 M：调用 reload(M) 后，M.x 为 新模块 的属性 x（由于更新M后，会影响M.x的求值结果）
• 对于由 from M import x 语句导入的属性 x：调用 reload(M) 后，x 仍然是 旧模块 的属性 x（由于更新M后，不会影响x的求值结果）
• 若是在调用 reload(M) 后，从新执行 import M（或者from M import x）语句，那么 M.x（或者x）为 新模块 的属性 x

8、参考资料

• https://github.com/Liuchang0812/slides/tree/master/pycon2015cn
• http://www.cnblogs.com/russellluo/p/3328683.html
• http://wiki.jikexueyuan.com/project/python-language-reference/import.html