python進階（28）import匯入機制原理

Silent丿丶黑羽發表於2022-11-23
PythonImport

前言

在Python中，一個.py檔案代表一個Module。在Module中可以是任何的符合Python檔案格式的Python指令碼。瞭解Module匯入機制大有用處。
 

1. Module組成

一個.py檔案就是一個module。Module中包括attribute, function等。 這裡說的attribute其實是module的global variable。
我們建立1個test1.py檔案，程式碼如下

# 定義1個全域性變數a
a = 1
# 宣告一個全域性變數moduleName
global moduleName


# 定義一個函式printModuleName
def printModuleName():
    print(a + 2)
    print(__name__)
    print(moduleName)

print(dir())

這裡我們定義了3個全域性變數a、moduleName、printModuleName，除了我們自己定義的以外還有module內建的全域性變數
 

1.1 Module 內建全域性變數

上面我們說到了，每一個模組都有內建的全域性變數，我們可以使用dir()函式，用於檢視模組內容，例如上面的例子中，使用dir()檢視結果如下：

['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'moduleName', 'printModuleName']

其中a, moduleName, printModuleName 是由使用者自定義的。其他的全是內建的。下面介紹幾個常用的內建全域性變數
 

1.1.1 __name__

指的是當前模組的名稱，比如上面的test1.py，模組的名稱預設就是test1，如果一個module是程式的入口，那麼__name__=__'main'__，這也是我們經常看到用到的
 

1.1.2 __builtins__

它就是內建模組builtins的引用。可以透過如下程式碼測試：

import builtins
print(builtins == __builtins__)

列印結果為True，在Python程式碼裡，不需要我們匯入就能直接使用的函式、類等，都是在這個內建模組裡的。例如：range、dir
 

1.1.3 __doc__

它就是module的文件說明，具體是檔案頭之後、程式碼（包含import）之前的第一個多行註釋，測試如下

點選檢視程式碼 
"""
模組匯入機制測試
"""


import builtins


# 定義1個全域性變數a
a = 1
# 宣告一個全域性變數moduleName
global moduleName


# 定義一個函式printModuleName
def printModuleName():
    print(a + 2)
    print(__name__)
    print(moduleName)


print(__doc__)

最後列印結果為

模組匯入機制測試

當然如果你想檢視某個方法的說明，也可以這麼使用

 

1.1.4 __file__

當前module所在的檔案的絕對路徑
 

1.1.5 __package__

當前module所在的包名。如果沒有，為None。
 

2. 包package

  為避免模組名衝突，Python引入了按目錄組織模組的方法，稱之為包（package）。包是含有Python模組的資料夾。

  當一個資料夾下有init.py時，意為該資料夾是一個包（package），其下的多個模組（module）構成一個整體，而這些模組（module）都可透過同一個包（package）匯入其他程式碼中。

  其中init.py檔案用於組織包（package），方便管理各個模組之間的引用、控制著包的匯入行為。

  該檔案可以什麼內容都不寫，即為空檔案，存在即可，相當於一個標記。

  但若想使用from pacakge_1 import *這種形式的寫法，需在init.py中加上：__all__ = ['file_a', 'file_b'] ，並且package_1下有file_a.py和file_b.py，在匯入時init.py檔案將被執行。

  但不建議在init.py中寫模組，以保證該檔案簡單。不過可在init.py匯入我們需要的模組，以便避免一個個匯入、方便使用。

  其中，__all__是一個重要的變數，用來指定此包（package）被import *時，哪些模組（module）會被import進【當前作用域中】。不在__all__列表中的模組不會被其他程式引用。可以重寫__all__，如__all__= ['當前所屬包模組1名字', '模組1名字']，如果寫了這個，則會按列表中的模組名進行匯入

  在模糊匯入時，形如from package import *，*是由__all__定義的。

  當我們在匯入一個包（package）時（會先載入__init__.py定義的引入模組，然後再執行其他程式碼），實際上是匯入的它的__init__.py檔案（匯入時，該檔案自動執行，助我們一下匯入該包中的多個模組）。我們可以在 init.py中再匯入其他的包（package）或模組或自定義類。
 

2.1 實戰案例

首先我們建立3個包，分別是test、test2、test3
test包下建立test1.py用來執行測試
test2包下建立file_a.py、file_b.py，用來測試包的匯入
test3包下建立file_c.py，輔助測試
具體結構如下：

核心程式碼在test2/__init__.py中如下

__all__ = ['file_a', 'file_b', 'file_c', 'test_d']


from test3 import file_c


def test_d():
    return "test_d"

解釋下，當我們在test/test1.py中寫了from test2 import *這句程式碼，程式不是直接匯入test2下的所有模組，而是匯入__init__.py檔案並自動執行，由於我們寫了__all__ = ['file_a', 'file_b', 'file_c', 'test_d']，file_a和file_b是當下包中的模組，file_c是我們從test3包中匯入的，test_d是__init__.py下我們定義的函式。

所以from test2 import *就是把__all__中指定的模組和函式匯入進來了，接著我們檢視test1.py下的程式碼

from test2 import *
print(file_a.a())
print(file_b.b())
print(file_c.c())
print(test_d())

如果列印有結果，則證明了匯入成功，並且匯入的是__all__下的模組和函式
 

3.sys.modules、名稱空間

 

3.1 sys.modules

sys.modules是一個將模組名稱對映到已載入的模組的字典。可用來強制重新載入modules。Python一啟動，它將被載入在記憶體中。

當我們匯入新modules，sys.modules將自動記錄下該module；當第二次再匯入該module時，Python將直接到字典中查詢，加快執行速度。

它是1個字典，故擁有字典的一切方法，如sys.modules.keys()、sys.modules.values()、sys.modules['os']。但請不要輕易替換字典、或從字典中刪除某元素，將可能導致Python執行失敗。
 

3.2 名稱空間

名稱空間就像一個dict，key是變數名字，value是變數的值。

  • 每個函式function都有自己的名稱空間，稱local namespace，記錄函式的變數。
  • 每個模組module都有自己的名稱空間，稱global namespace，記錄模組的變數，包括functions、classes、匯入的modules、module級別的變數和常量。
  • build-in名稱空間，它包含build-in function和exceptions，可被任意模組訪問。

假設你要訪問某段Python程式碼中的變數x時，Python會在所有的名稱空間中查詢該變數，順序是：

  1. local namespace 即當前函式或類方法。若找到，則停止搜尋；
  2. global namespace 即當前模組。若找到，則停止搜尋；
  3. build-in namespace Python會假設變數x是build-in的內建函式或變數。若變數x不是build-in的內建函式或變數，Python將報錯NameError。
  4. 對於閉包，若在local namespace找不到該變數，則下一個查詢目標是父函式的local namespace。
     

我們可以看一個小例子

# test_namespace.py
def func(a=1):
    b = 2
    print(locals())  # 列印當前函式的區域性名稱空間
    '''
    locs = locals()  # 只讀，不可寫，會報錯
    locs['c'] = 3
    print(c)
    '''
    return a + b


func()
glos = globals()
glos['d'] = 4
print(d)
print(globals())

執行func()會列印函式func的區域性名稱空間，結果如下：

{'a': 1, 'b': 2}

執行print(globals())會列印模組test_namespace的全域性名稱空間，結果如下：

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fde2605c730>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/jkc/PycharmProjects/pythonProject1/test_namespace.py', '__cached__': None, 'func': <function func at 0x7fde246b9310>, 'glos': {...}, 'd': 4}

內建函式locals()、globals()都會返回一個字典。區別：前者只讀、後者可寫。

名稱空間在from module_name import 、import module_name中的體現：from關鍵詞是匯入模組或包中的某個部分。

  1. from module_A import X：會將該模組的函式/變數匯入到當前模組的名稱空間中，無須用module_A.X訪問了。
  2. import module_A：modules_A本身被匯入，但儲存它原有的名稱空間，故得用module_A.X方式訪問其函式或變數。
    接下來我們測試一下：

可以看到我們匯入了函式a和模組file_c，接著我們列印了全域性變數，結果如下：

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7fab9585c730>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '/Users/jkc/PycharmProjects/pythonProject1/test3/test_namespace.py', '__cached__': None, 'a': <function a at 0x7fab95b04040>, 'file_c': <module 'file_c' from '/Users/jkc/PycharmProjects/pythonProject1/test3/file_c.py'>}

可以很清楚的看到全域性變數中有函式a和模組file_c，接著我們嘗試能否呼叫者2個

from test2.file_a import a
import file_c


print(globals())


file_c.c()
a()

最後也是可以成功呼叫
 

4. 匯入

準備工作如下：

 

4.1 絕對匯入

所有的模組import都從“根節點”開始。根節點的位置由sys.path中的路徑決定，專案的根目錄一般自動在sys.path中。如果希望程式能處處執行，需手動修改sys.path。

例1：c.py中匯入B包/B1子包/b1.py模組

import os
import sys


BASE_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.append(BASE_DIR)

# 匯入B包中的子包B1中的模組b1
from B.B1 import b1

例2：b1.py中匯入b2.py模組

# 從B包中的子包B1中匯入模組b2
from B.B1 import b2

 

4.2 相對匯入

只關心相對自己當前目錄的模組位置就好。不能在包（package）的內部直接執行（會報錯）。不管根節點在哪兒，包內的模組相對位置都是正確的。

b1.py程式碼如下：

# from . import b2  # 這種匯入方式會報錯
import b2  # 正確
b2.print_b2()

b2.py程式碼如下：

def print_b2():
    print('b2')

最後執行b1.py，列印b2。
 

4.3 單獨匯入包

單獨import某個包名稱時，不會匯入該包中所包含的所有子模組。

c.py匯入同級目錄B包的子包B1包的b2模組，執行b2模組的print_b2()方法：
c.py程式碼

import B
B.B1.b2.print_b2()

執行c.py會以下錯誤

AttributeError: module 'B' has no attribute 'B1'

因為import B並不會自動將B下的子模組匯入進去，需要手動新增，解決辦法如下
在B/init.py程式碼下新增如下程式碼

from . import B1

在B/B1/init.py程式碼下新增如下程式碼

from . import b2

此時，執行c.py，成功列印b2。
 

5. import執行機制

我們要理解Python在執行import語句時，進行了啥操作？
step1：建立一個新的、空的module物件（它可能包含多個module）；
step2：將該module物件 插入sys.modules中；
step3：裝載module的程式碼（如果需要，需先編譯）；
step4：執行新的module中對應的程式碼。

在執行step3時，首先需找到module程式所在的位置，如匯入的module名字為mod_1，則直譯器得找到mod_1.py檔案，搜尋順序是：
當前路徑（或當前目錄指定sys.path）->PYTHONPATH->Python安裝設定相關的預設路徑。

對於不在sys.path中，一定要避免用import匯入自定義包（package）的子模組（module），而要用from…import… 的絕對匯入或相對匯入，且包（package）的相對匯入只能用from形式。
 

5.1 標準import，頂部匯入


 

5.2 巢狀import

 

5.2.1 順序匯入-import

  1. moduleB定義了變數b=2
  2. moduleA匯入模組moduleB，當然moduleB還可以匯入其他模組
  3. test模組匯入moduleA

最後執行test.py，將列印3
 

5.2.2 迴圈匯入/巢狀匯入

moduleA.py

from moduleB import ClassB


class ClassA:
    pass

moduleB.py

from moduleA import ClassA


class ClassB:
    pass

當執行moduleA.py時會報錯

ImportError: cannot import name 'ClassA' from partially initialized module 'moduleA'

報錯分析：

  1. 在執行moduleA時，首選會執行from moduleB import ClassB程式碼
  2. 程式會判斷sys.modules中是否有
  3. 有代表字在第一次執行時，建立的物件已經快取在sys.modules，直接得到，不過依然是空物件，因為__dict__找不到ClassB，會報錯
  4. 沒有會為moduleB.py建立1個module物件，此時建立的module物件為空
    4.1 然後執行moduleB.py的第一條語句from moduleA import ClassA
    PS：這麼做的原因是python內部建立了module物件後立馬執行moduleB.py，目的是填充<module moduleB>的__dict__，當然最終未能成功填充
    4.2 接著判斷sys.modules中是否有
    4.3 沒有會為moduleA.py建立1個module物件
    PS：此時建立的module物件同樣為空，則需要執行moduleA.py語句from moduleB import ClassB
  5. 最後回到操作2的過程，這次判斷有module物件，會進行操作3，最後就會報錯cannot import name 'ClassA'

解決辦法：組織程式碼（重構程式碼）：更改程式碼佈局，可合併或分離競爭資源。
 

參考內如如下：
Python 3.x | 史上最詳解的匯入（import)
Python Module

相關文章