許多年來不時使用Python的人并不是都知道Python的導入機制其實非常靈活。在本文中，我們將探討以下話題：

• 常規導入（regular imports）
• 使用from語句導入
• 相對導入（relative imports）
• 可選導入（optional imports）
• 本地導入（local imports）
• 導入注意事項
• 如何避免循環導入

常規導入

常規導入應該是最常使用的導入方式，大概是這樣的：

import sys

你只需要使用import一詞，然后指定你希望導入的模塊或包即可。通過這種方式導入的好處是可以一次性導入多個包或模塊：

import os, sys, time

雖然這節省了空間，但是卻違背了Python風格指南。Python風格指南建議將每個導入語句單獨成行。

有時在導入模塊時，你想要重命名這個模塊。這個功能很容易實現：

import sys as systemprint(system.platform)

上面的代碼將我們導入的sys模塊重命名為system。我們可以按照和以前一樣的方式調用模塊的方法，但是可以用一個新的模塊名。也有某些子模塊必須要使用點標記法才能導入。

import urllib.error

這個情況不常見，但是對此有所了解總是沒有壞處的。

使用from語句導入

很多時候你只想要導入一個模塊或庫中的某個部分。我們來看看在Python中如何實現這點：

from functools import lru_cache

上面這行代碼可以讓你直接調用lru_cache。如果你按常規方式導入functools，那么你就必須像這樣調用lru_cache：

functools.lru_cache(*args)

根據你實際的使用場景，上面的做法可能是更好的。在復雜的代碼庫中，能夠看出某個函數是從哪里導入的這點很有用的。不過，如果你的代碼維護的很好，模塊化程度高，那么只從某個模塊中導入一部分內容也是非常方便和簡潔的。

當然，你還可以使用from方法導入模塊的全部內容，就像這樣：

from os import *

這種做法在少數情況下是挺方便的，但是這樣也會打亂你的命名空間。問題在于，你可能定義了一個與導入模塊中名稱相同的變量或函數，這時如果你試圖使用os模塊中的同名變量或函數，實際使用的將是你自己定義的內容。因此，你最后可能會碰到一個相當讓人困惑的邏輯錯誤。標準庫中我唯一推薦全盤導入的模塊只有Tkinter。

如果你正好要寫自己的模塊或包，有人會建議你在__init__.py文件中導入所有內容，讓模塊或者包使用起來更方便。我個人更喜歡顯示地導入，而非隱式地導入。

你也可以采取折中方案，從一個包中導入多個項：

from os import path, walk, unlink from os import uname, remove

在上述代碼中，我們從os模塊中導入了5個函數。你可能注意到了，我們是通過多次從同一個模塊中導入實現的。當然，如果你愿意的話，你也可以使用圓括號一次性導入多個項：

from os import (path, walk, unlink, uname, remove, rename)

這是一個有用的技巧，不過你也可以換一種方式：

from os import path, walk, unlink, uname, \remove, rename

上面的反斜杠是Python中的續行符，告訴解釋器這行代碼延續至下一行。

相對導入

PEP 328介紹了引入相對導入的原因，以及選擇了哪種語法。具體來說，是使用句點來決定如何相對導入其他包或模塊。這么做的原因是為了避免偶然情況下導入標準庫中的模塊產生沖突。這里我們以PEP 328中給出的文件夾結構為例，看看相對導入是如何工作的：

my_package/__init__.pysubpackage1/__init__.pymodule_x.pymodule_y.pysubpackage2/__init__.pymodule_z.pymodule_a.py

在本地磁盤上找個地方創建上述文件和文件夾。在頂層的__init__.py文件中，輸入以下代碼：

from . import subpackage1 from . import subpackage2

接下來進入subpackage1文件夾，編輯其中的__init__.py文件，輸入以下代碼：

from . import module_x from . import module_y

現在編輯module_x.py文件，輸入以下代碼：

from .module_y import spam as hamdef main():ham()

最后編輯module_y.py文件，輸入以下代碼：

def spam():print('spam ' * 3)

打開終端，cd至my_package包所在的文件夾，但不要進入my_package。在這個文件夾下運行Python解釋器。我使用的是IPython，因為它的自動補全功能非常方便：

In [1]: import my_packageIn [2]: my_package.subpackage1.module_x Out[2]: <module 'my_package.subpackage1.module_x' from 'my_package/subpackage1/module_x.py'>In [3]: my_package.subpackage1.module_x.main() spam spam spam

相對導入適用于你最終要放入包中的代碼。如果你編寫了很多相關性強的代碼，那么應該采用這種導入方式。你會發現PyPI上有很多流行的包也是采用了相對導入。還要注意一點，如果你想要跨越多個文件層級進行導入，只需要使用多個句點即可。不過，PEP 328建議相對導入的層級不要超過兩層。

還要注意一點，如果你往module_x.py文件中添加了if __name__ == ‘__main__’，然后試圖運行這個文件，你會碰到一個很難理解的錯誤。編輯一下文件，試試看吧！

from . module_y import spam as hamdef main():ham()if __name__ == '__main__':# This won't work!main()

現在從終端進入subpackage1文件夾，執行以下命令：

python module_x.py

如果你使用的是Python 2，你應該會看到下面的錯誤信息：

Traceback (most recent call last):File "module_x.py", line 1, in <module>from . module_y import spam as ham ValueError: Attempted relative import in non-package

如果你使用的是Python 3，錯誤信息大概是這樣的：

Traceback (most recent call last):File "module_x.py", line 1, in <module>from . module_y import spam as ham SystemError: Parent module '' not loaded, cannot perform relative import

這指的是，module_x.py是某個包中的一個模塊，而你試圖以腳本模式執行，但是這種模式不支持相對導入。

如果你想在自己的代碼中使用這個模塊，那么你必須將其添加至Python的導入檢索路徑（import search path）。最簡單的做法如下：

import sys sys.path.append('/path/to/folder/containing/my_package') import my_package

注意，你需要添加的是my_package的上一層文件夾路徑，而不是my_package本身。原因是my_package就是我們想要使用的包，所以如果你添加它的路徑，那么將無法使用這個包。

我們接下來談談可選導入。

可選導入（Optional imports）

如果你希望優先使用某個模塊或包，但是同時也想在沒有這個模塊或包的情況下有備選，你就可以使用可選導入這種方式。這樣做可以導入支持某個軟件的多種版本或者實現性能提升。以github2包中的代碼為例：

try:# For Python 3from http.client import responses except ImportError: # For Python 2.5-2.7try:from httplib import responses # NOQAexcept ImportError: # For Python 2.4from BaseHTTPServer import BaseHTTPRequestHandler as _BHRHresponses = dict([(k, v[0]) for k, v in _BHRH.responses.items()])

lxml包也有使用可選導入方式：

try:from urlparse import urljoinfrom urllib2 import urlopen except ImportError:# Python 3from urllib.parse import urljoinfrom urllib.request import urlopen

正如以上示例所示，可選導入的使用很常見，是一個值得掌握的技巧。

局部導入

當你在局部作用域中導入模塊時，你執行的就是局部導入。如果你在Python腳本文件的頂部導入一個模塊，那么你就是在將該模塊導入至全局作用域，這意味著之后的任何函數或方法都可能訪問該模塊。例如：

import sys # global scopedef square_root(a):# This import is into the square_root functions local scopeimport mathreturn math.sqrt(a)def my_pow(base_num, power):return math.pow(base_num, power)if __name__ == '__main__':print(square_root(49))print(my_pow(2, 3))

這里，我們將sys模塊導入至全局作用域，但我們并沒有使用這個模塊。然后，在square_root函數中，我們將math模塊導入至該函數的局部作用域，這意味著math模塊只能在square_root函數內部使用。如果我們試圖在my_pow函數中使用math，會引發NameError。試著執行這個腳本，看看會發生什么。

使用局部作用域的好處之一，是你使用的模塊可能需要很長時間才能導入，如果是這樣的話，將其放在某個不經常調用的函數中或許更加合理，而不是直接在全局作用域中導入。老實說，我幾乎從沒有使用過局部導入，主要是因為如果模塊內部到處都有導入語句，會很難分辨出這樣做的原因和用途。根據約定，所有的導入語句都應該位于模塊的頂部。

導入注意事項

在導入模塊方面，有幾個程序員常犯的錯誤。這里我們介紹兩個。

• 循環導入（circular imports）
• 覆蓋導入（Shadowed imports，暫時翻譯為覆蓋導入）

先來看看循環導入。

循環導入

如果你創建兩個模塊，二者相互導入對方，那么就會出現循環導入。例如：

# a.py import bdef a_test():print("in a_test")b.b_test()a_test()

然后在同個文件夾中創建另一個模塊，將其命名為b.py。

import adef b_test():print('In test_b"')a.a_test()b_test()

如果你運行任意一個模塊，都會引發AttributeError。這是因為這兩個模塊都在試圖導入對方。簡單來說，模塊a想要導入模塊b，但是因為模塊b也在試圖導入模塊a（這時正在執行），模塊a將無法完成模塊b的導入。我看過一些解決這個問題的破解方法（hack），但是一般來說，你應該做的是重構代碼，避免發生這種情況。

覆蓋導入

當你創建的模塊與標準庫中的模塊同名時，如果你導入這個模塊，就會出現覆蓋導入。舉個例子，創建一個名叫math.py的文件，在其中寫入如下代碼：

import mathdef square_root(number):return math.sqrt(number)square_root(72)

現在打開終端，試著運行這個文件，你會得到以下回溯信息（traceback）：

Traceback (most recent call last):File "math.py", line 1, in <module>import mathFile "/Users/michael/Desktop/math.py", line 6, in <module>square_root(72)File "/Users/michael/Desktop/math.py", line 4, in square_rootreturn math.sqrt(number) AttributeError: module 'math' has no attribute 'sqrt'

這到底是怎么回事？其實，你運行這個文件的時候，Python解釋器首先在當前運行腳本所處的的文件夾中查找名叫math的模塊。在這個例子中，解釋器找到了我們正在執行的模塊，試圖導入它。但是我們的模塊中并沒有叫sqrt的函數或屬性，所以就拋出了AttributeError。

如何避免循環導入

Python 中使用package時，出現循環導入問題十分常見，我們創建如下package來說明這個問題:

pkg├── __init__.py├── module_a.py└── module_b.py

其中，

• __init__.py?將pkg指定為一個Python package
• module_a.py中定義了一個action_a()函數，該函數引用了module_b.py中的一個attribute，如一個函數或變量
• module_b.py中定義了一個action_b()函數，該函數引用了module_a.py中的一個attribute，如一個函數或變量

這種情況下，執行該package時會拋出circular import error錯誤，即循環引用，因為module_a試圖去引入module_b時，而module_b首先要引入module_a，這會導致Python解釋器無法執行下去。

然而，我們可以通過一些巧妙的方法，讓上面的邏輯正常工作，同時避免循環引入的錯誤。

那么，什么時候它能正常工作，什么時候不能正常工作，而那些能夠正常工作的情況又是什么原因呢？

何時它能正常工作？

1. 在module頂部引入，不要用from，相對引入，只在Python 2中有效

在module的頂部import，如import another_module，module 中的函數以another_module.attribute的方式引用another_module中的函數或變量等。這種方式之所以有效，是由于import another_module是基于當前目錄的相對引用，而且是一種隱式引用，如果從另一個package中引入module時，就可以失效了。另外，import another_module這種語法在Python 3 中已經不支持了，所以不要在代碼中用這種方法來避免循環引入。

如：

# pkg/module_a.py from __future__ import print_function import module_bdef action_a():print(module_b.action_b.__name__)# pkg/module_b.py from __future__ import print_function import module_adef action_b():print(module_a.action_a.__name__)

2. 在module的頂部引入，不要用from，絕對引入

在module的頂部import，使用從package開始的絕對路徑，如import package.another_module，module 中的函數以package.another_module.attribute的方式引用another_module中的函數或變量等。之所以要掛上package name來引入，是由于import .another_module這種形式的“相對引入”會報語法錯誤，而掛上package的絕對引入，Python 2和3都支持

案例：

# pkg/module_a.py from __future__ import print_function import pkg2.module_bdef action_a():print(pkg2.module_b.action_b.__name__)# pkg/module_b.py from __future__ import print_function import pkg2.module_adef action_b():print(pkg2.module_a.action_a.__name__)

3. 在module底部引入another module的attribute，而非another module，用from

在module的底部import（至少要在被引用的attribute之后import），直接引入another module的attribute，如from package.another_module import attribute，相對引入也支持，如from .another_module import attribute，module中的函數直接使用被引用的attribute即可。

如：

# pkg/module_a.py from __future__ import print_functiondef action_a():print(action_b.__name__)from .module_b import action_b# pkg/module_b.py from __future__ import print_functiondef action_b():print(action_a.__name__)from .module_a import action_a

4. 函數頂部引入，可以用from

在module的function頂部import，如from package import another_module，也支持相對引入，引入module或attribute均可。

如：

# pkg/module_a.py from __future__ import print_functiondef action_a():from . import module_bprint(module_b.action_b.__name__)# pkg/module_b.py from __future__ import print_functiondef action_b():from . import module_aprint(module_a.action_a.__name__)

或

# pkg/module_a.py from __future__ import print_functiondef action_a():from .module_b import action_bprint(action_b.__name__)# pkg/module_b.py from __future__ import print_function def action_b():from .module_a import action_aprint(action_a.__name__)

這種方式雖然Python 2和3都支持，但編碼不夠優雅，影響代碼可讀性，不建議使用

注

• 本文討論的問題，是Python中調用package時，應如何避免循環引入
• 當直接在命令行執行一個Python module時，適用情況不完全相同
• 本文內容我在GitHub上提供了一個Demo，歡迎查看或fork
• Reference：This Gist

總結

在本文中，我們講了很多有關導入的內容，但是還有部分內容沒有涉及。PEP 302中介紹了導入鉤子（import hooks），支持實現一些非常酷的功能，比如說直接從github導入。Python標準庫中還有一個importlib模塊，值得查看學習。當然，你還可以多看看別人寫的代碼，不斷挖掘更多好用的妙招。

總結

以上是生活随笔為你收集整理的Python导入全局、局部模块以及如何让避免循环导入的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。