深入理解python之模塊系統(tǒng)
一個python工程中的代碼是通過模塊與包的形式組織的。概括的說，一個python的文件在運行時對應一個模塊，而一個文件夾（包含有init.py）對應于一個包。一個模塊對于其他模塊或者包中內容的引用是通過import 關鍵字來實現(xiàn)的。在成規(guī)模的項目開發(fā)中，不同的模塊，包之間的引用關系，以及搜索路徑常常使人困擾。因此，認識python模塊的本質，理清python底層import的處理機制，是有意義的。
本文分四個部分梳理python的模塊系統(tǒng) 。第一部分介紹python module 對象的具體數據結構；第二部分介紹python的包與模塊；第三部分詳細梳理import 語句的底層邏輯；最后一部分，會圍繞python 的import機制談談在開發(fā)過程中的一些細節(jié)。
PyModuleObject 對象
無論是與py文件對應的模塊，還是與文件夾對應的包，在python的底層實現(xiàn)中，都是用一個PyModuleObject類型的對象去描述的。
typedef struct {
PyObject_Head
PyObject *md_dict
}PyModuleObject;
可以看出，PyModuleObject 對象里的主體是一個字典對象。由此我們可以看出。其實一個python module 就是一個python字典。站在更高層次上來看，一個python module 主要就是提供了一個命名空間，用于保存各類對象（變量，函數，類。。。）。一個module對象持有的命名空間里保存的內容，可以通過dir函數等方法訪問
import xxx
dir(xxx)
模塊與包
在python項目中，運行時內存的一個模塊對象，對應于一個py文件，而一個包對象則對應于python項目中的一個包含了 __ init __. py文件的文件夾。
無論是一個模塊對象還是一個包對象，在python底層都統(tǒng)一用一個PyModuleObject 對象來保存。
>>>import os #包
>>> import os.path #模塊
>>> type(os)
<type 'module'>
>>> type(os.path)
<type 'module'>
如我們所知，對于一個與py文件對應的模塊，其在首次import的過程中，會執(zhí)行其中的邏輯。
與之對應的是，一個包在首次import的過程中,會執(zhí)行包中__ init __.py中的邏輯。
import 內幕
在python實現(xiàn)中，import 機制的核心實現(xiàn)位于import_module_level 函數中。
static PyObject *import_module_level(char *name, PyObject *globals, PyObject *locals,PyObject *fromlist, int level)
{
// 獲取當前import 語句的執(zhí)行環(huán)境
parent = get_parent(globals, buf, &buflen, level);
...
// 沿著import 路徑鏈，依次加載包與模塊
head = load_next(parent, level < 0 ? Py_None : parent, &name, buf,&buflen);
tail = head;
while (name) {
next = load_next(tail, tail, &name, buf, &buflen);
tail = next;
}
...
}
獲取import 語句執(zhí)行環(huán)境
在import_module_level函數中，第一個核心的操作是獲取import 語句的執(zhí)行環(huán)境。這個操作是通過get_parent 函數來獲得的。所謂import 的執(zhí)行環(huán)境，即為當前import 語句所在模塊所屬的package。
舉例來說，假設當前有一個包叫做test_pkg，內含有py文件test_mod.py。test_mod.py 內含有一個import語句。
# test_mod.py
import x.y.z
那么當虛擬機執(zhí)行import語句，并觸發(fā)import_module_level 函數調用后，其中的get_parent 操作返回的執(zhí)行環(huán)境，即為test_pkg。如前文所述，test_pkg 此時也是通過一個PyModuleObject 描述的。
向下接續(xù)探究get_parent 可以發(fā)現(xiàn)，該函數大部分情況下是通過解析當前模塊的__ name __ 屬性獲取到上層package 的名稱，從而在全局的sys.modules 查詢到package 對象的。
正常情況下 test_mod.py 對應的模塊其 __ name __ 屬性的值為“test_pkg.test_mod" 。根據最后一個"."符號的位置，可以獲取到上層package 名稱。
一個特殊情況是，假如我們將test_mod 定為啟動模塊（執(zhí)行python test_mod.py）這個時候test_mod模塊的 __ name __ 屬性值為 “__ main __” 。此時其上層執(zhí)行環(huán)境被設置為 Py_None。
沿import 路徑鏈依次加載包與模塊
在獲取了執(zhí)行環(huán)境之后，接下來就要正式開始加載包與模塊了。對于語句 import x.y.z 。
x->y->z 可以看做是一個鏈表，import_module_level函數中，會做一個類似于鏈表遍歷的操作，對于每個節(jié)點，都執(zhí)行加載操作。
// 沿著import 路徑鏈，依次加載包與模塊
head = load_next(parent, level < 0 ? Py_None : parent, &name, buf,&buflen);
tail = head;
while (name) {
next = load_next(tail, tail, &name, buf, &buflen);
tail = next;
}
load_next 中的核心函數是 import_submodule 函數
static PyObject *import_submodule(PyObject *mod, char *subname, char *fullname){
// 檢查模塊是否已經被加載到sys.modules 中
if ((m = PyDict_GetItemString(modules, fullname)) != NULL) {
Py_INCREF(m);
}
// 試圖從mod.__path__ 獲取包或者模塊的加載路徑
if (mod == Py_None)
path = NULL;
else {
path = PyObject_GetAttrString(mod, "__path__");
if (path == NULL) {
PyErr_Clear();
Py_INCREF(Py_None);
return Py_None;
}
}
// 搜索模塊
fdp = find_module(fullname, subname, path, buf, MAXPATHLEN+1,
&fp, &loader);
// 加載模塊
m = load_module(fullname, fp, buf, fdp->type, loader);
Py_XDECREF(loader);
// 將目標模塊加入到上層package 對象的名字空間中
if (!add_submodule(mod, m, fullname, subname, modules)) {
Py_XDECREF(m);
m = NULL;
}
}
return m;
}
在import_submodule 函數中，
首先會檢測目標名稱對應的PyModuleObject 對象是否已經被加載到sys.modules字典中。
如果 sys.modules 中沒有找到這個模塊對象，那么說明這個模塊是全局第一次被加載。會接著執(zhí)行下列操作。
根據當前傳入package對象的__ path __ 屬性獲取目標包或者模塊的搜索路徑。如果傳入package對象為PyNone （對應于__ name __ == "__ main __" 等情況），那么路徑為NULL。
-
在獲取了path之后，python底層通過find_module 函數搜索 目標 包 或者 模塊的 文件系統(tǒng)句柄。
find_module的模塊搜索策略是這樣的：首先在傳入的path（也就是父級package的路徑）下搜索目標，如果path為NULL，或者在path下搜索失敗，則依次在sys.path 列表中出現(xiàn)的路徑下進行搜索。
-
load_module 執(zhí)行模塊或者包的實際加載動作。
load_module 會根據目標PyModuleObject 對象的預期類型做不同的操作：
load_module(){
switch(type){
case py_source:
// 如果模塊是py
1.編譯
2.執(zhí)行代碼
3.創(chuàng)建 module 對象
4.將執(zhí)行時的global 空間 放入到module->m_dict 中
5. 返回 module 對象
break
case py_complied:
// 如果模塊是pyc，則沒有編譯那個過程
1.執(zhí)行代碼
2.創(chuàng)建 module 對象
3.將執(zhí)行時的global 空間 放入到module->m_dict 中
4. 返回 module 對象
break
case c_extension：
// 如果模塊是c 擴展
1. 加載動態(tài)鏈接庫
2. 執(zhí)行initmodule 函數,其中要調用Py_InitModule api
break
case pkg：
// 如果模塊是 package
1.創(chuàng)建模塊
2.加載__init__.py, load_module(__init__.py).
break
}
}
- add_submodule 函數將load進來的目標PyModuleObject 插入到父級PyModuleObject中。
