模塊導入小結

做爲一名Python程序員，你首先須要學習的內容之一就是如何導入模塊或包。可是我注意到，那些許多年來不時使用Python的人並非都知道Python的導入機制其實很是靈活。在本文中，咱們將探討如下話題：

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

常規導入

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

import sys
複製代碼

你只須要使用import一詞，而後指定你但願導入的模塊或包便可。經過這種方式導入的好處是能夠一次性導入多個包或模塊：

import os, sys, time
複製代碼

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

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

import sys as system

print(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__.py
    subpackage1/
        __init__.py
        module_x.py
        module_y.py
    subpackage2/
        __init__.py
        module_z.py
    module_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 ham

def main():
    ham()
複製代碼

最後編輯module_y.py文件，輸入如下代碼：

def spam():
    print('spam ' * 3)
複製代碼

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

In [1]: import my_package

In [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 ham

def 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 3
    from http.client import responses
except ImportError:  # For Python 2.5-2.7
    try:
        from httplib import responses  # NOQA
    except ImportError:  # For Python 2.4
        from BaseHTTPServer import BaseHTTPRequestHandler as _BHRH
        responses = dict([(k, v[0]) for k, v in _BHRH.responses.items()])
複製代碼

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

try:
    from urlparse import urljoin
    from urllib2 import urlopen
except ImportError:
    # Python 3
    from urllib.parse import urljoin
    from urllib.request import urlopen
複製代碼

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

局部導入

當你在局部做用域中導入模塊時，你執行的就是局部導入。若是你在Python腳本文件的頂部導入一個模塊，那麼你就是在將該模塊導入至全局做用域，這意味着以後的任何函數或方法均可能訪問該模塊。例如：

import sys  # global scope

def square_root(a):
    # This import is into the square_root functions local scope
    import math
    return 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 b

def a_test():
    print("in a_test")
    b.b_test()

a_test()
複製代碼

而後在同個文件夾中建立另外一個模塊，將其命名爲b.py。

import a

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

b_test()
複製代碼

若是你運行任意一個模塊，都會引起AttributeError。這是由於這兩個模塊都在試圖導入對方。簡單來講，模塊a想要導入模塊b，可是由於模塊b也在試圖導入模塊a（這時正在執行），模塊a將沒法完成模塊b的導入。我看過一些解決這個問題的破解方法（hack），可是通常來講，你應該作的是重構代碼，避免發生這種狀況。

覆蓋導入

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

import math

def square_root(number):
    return math.sqrt(number)

square_root(72)
複製代碼

如今打開終端，試着運行這個文件，你會獲得如下回溯信息（traceback）：

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

這究竟是怎麼回事？其實，你運行這個文件的時候，Python解釋器首先在當前運行腳本所處的的文件夾中查找名叫math的模塊。在這個例子中，解釋器找到了咱們正在執行的模塊，試圖導入它。可是咱們的模塊中並無叫sqrt的函數或屬性，因此就拋出了AttributeError。

總結

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