python模組及外部包的匯入（https://blog.csdn.net/ennaymonkey/article/details/77890585）

一 .module

通常模組為一個檔案，直接使用import來匯入就好了。可以作為module的檔案型別有".py"、".pyo"、".pyc"、".pyd"、".so"、".dll"。

二. package

通常包總是一個目錄，可以使用import匯入包，或者from + import來匯入包中的部分模組。包目錄下為首的一個檔案便是 __init__.py。然後是一些模組檔案和子目錄，假如子目錄中也有 __init__.py 那麼它就是這個包的子包了。
 
 一.模組你可以使用import語句將一個原始碼檔案作為模組匯入.例如:
[python] view plain copy

1. # file : spam.py  
2. a = 37                    # 一個變數  
3. def foo:                  # 一個函式  
4.     print "I'm foo"  
5. class bar:                # 一個類  
6.     def grok(self):  
7.         print "I'm bar.grok"  
8. b = bar()                 # 建立一個例項  

1. # file : spam.py

2. a = 37 # 一個變數

3. def foo: # 一個函式

4. print "I'm foo"

5. class bar: # 一個類

6. def grok(self):

7. print "I'm bar.grok"

8. b = bar() # 建立一個例項

使用import spam 語句就可以將這個檔案作為模組匯入。系統在匯入模組時，要做以下三件事：

1.為原始碼檔案中定義的物件建立一個名字空間，通過這個名字空間可以訪問到模組中定義的函式及變數。
2.在新建立的名字空間裡執行原始碼檔案.
3.建立一個名為原始碼檔案的物件，該物件引用模組的名字空間，這樣就可以通過這個物件訪問模組中的函式及變數，如：  
[python] view plain copy

1. import spam           # 匯入並執行模組 spam  
2. print spam.a          # 訪問模組 spam 的屬性  
3. spam.foo()  
4. c = spam.bar()  

1. import spam # 匯入並執行模組 spam

2. print spam.a # 訪問模組 spam 的屬性

3. spam.foo()

4. c = spam.bar()

用逗號分割模組名稱就可以同時匯入多個模組:

 

[python] view plain copy

1. import socket, os, regex  

import socket, os, regex

模組匯入時可以使用 as 關鍵字來改變模組的引用物件名字:[python] view plain copy

1. import os as system  
2. import socket as net, thread as threads  
3. system.chdir("..")  
4. net.gethostname()  

1. import os as system

2. import socket as net, thread as threads

3. system.chdir("..")

4. net.gethostname()

使用from語句可以將模組中的物件直接匯入到當前的名字空間. from語句不建立一個到模組名字空間的引用物件，而是把被匯入模組的一個或多個物件直接放入當前的名字空間:
[python] view plain copy

1. from socket import gethostname # 將gethostname放如當前名字空間  
2. print gethostname()            # 直接呼叫  
3. socket.gethostname()           # 引發異常NameError: socket  

1. from socket import gethostname # 將gethostname放如當前名字空間

2. print gethostname() # 直接呼叫

3. socket.gethostname() # 引發異常NameError: socket

from語句支援逗號分割的物件，也可以使用星號(*)代表模組中除下劃線開頭的所有物件:

[python] view plain copy

1. from socket import gethostname, socket  
2. from socket import *   # 載入所有物件到當前名字空間  

1. from socket import gethostname, socket

2. from socket import * # 載入所有物件到當前名字空間

不過，如果一個模組如果定義有列表__all__，則from module import * 語句只能匯入__all__列表中存在的物件。
[python] view plain copy

1. # module: foo.py  
2. __all__ = [ 'bar', 'spam' ]     # 定義使用 `*` 可以匯入的物件  

1. # module: foo.py

2. __all__ = [ 'bar', 'spam' ] # 定義使用 `*` 可以匯入的物件

另外, as 也可以和 from 聯合使用:

[python] view plain copy

1. from socket import gethostname as hostname  
2. h = hostname()  

1. from socket import gethostname as hostname

2. h = hostname()

import 語句可以在程式的任何位置使用，你可以在程式中多次匯入同一個模組，但模組中的程式碼*僅僅*在該模組被首次匯入時執行。後面的import語句只是簡單的建立一個到模組名字空間的引用而已。sys.modules字典中儲存著所有被匯入模組的模組名到模組物件的對映。這個字典用來決定是否需要使用import語句來匯入一個模組的最新拷貝.

from module import * 語句只能用於一個模組的最頂層.*特別注意*：由於存在作用域衝突，不允許在函式中使用from 語句。 
每個模組都擁有 __name__ 屬性，它是一個內容為模組名字的字串。最頂層的模組名稱是 __main__ .命令列或是互動模式下程式都執行在__main__ 模組內部. 利用__name__屬性，我們可以讓同一個程式在不同的場合（單獨執行或被匯入)具有不同的行為，象下面這樣做：
[python] view plain copy

1. # 檢查是單獨執行還是被匯入  
2.   
3. if __name__ == '__main__':  
4.       # Yes  
5.       statements  
6. else:  
7.       # No (可能被作為模組匯入)  
8.       statements   

1. # 檢查是單獨執行還是被匯入

2.  

3. if __name__ == '__main__':

4. # Yes

5. statements

6. else:

7. # No (可能被作為模組匯入)

8. statements

模組搜尋路徑
匯入模組時,直譯器會搜尋sys.path列表,這個列表中儲存著一系列目錄。一個典型的sys.path 列表的值：
Linux:
['', '/usr/local/lib/python2.0',
     '/usr/local/lib/python2.0/plat-sunos5',
     '/usr/local/lib/python2.0/lib-tk',
     '/usr/local/lib/python2.0/lib-dynload',
     '/usr/local/lib/python2.0/site-packages']
Windows:
['', 'C:\\WINDOWS\\system32\\python24.zip', 'C:\\Documents and Settings\\weizhong', 'C:\\Python24\\DLLs', 'C:\\Python24\\lib', 'C:\\Python24\\lib\\plat-win', 'C:\\Python24\\lib\\lib-tk', 'C:\\Python24\\Lib\\site-packages\\pythonwin', 'C:\\Python24', 'C:\\Python24\\lib\\site-packages', 'C:\\Python24\\lib\\site-packages\\win32', 'C:\\Python24\\lib\\site-packages\\win32\\lib', 'C:\\Python24\\lib\\site-packages\\wx-2.6-msw-unicode']
空字串 代表當前目錄. 要加入新的搜尋路徑,只需要將這個路徑加入到這個列表. 
 
模組匯入和彙編
到現在為止，本章介紹的模組都是包含Python原始碼的文字檔案. 不過模組不限於此，可以被 import 語句匯入的模組共有以下四類: 
•使用Python寫的程式( .py檔案)
•C或C++擴充套件(已編譯為共享庫或DLL檔案)
•包(包含多個模組)
•內建模組(使用C編寫並已連結到Python直譯器內)
當查詢模組 foo 時,直譯器按照 sys.path 列表中目錄順序來查詢以下檔案(目錄也是檔案的一種): 
1.定義為一個包的目錄 foo
2.foo.so, foomodule.so, foomodule.sl,或 foomodule.dll (已編譯擴充套件)
3.foo.pyo (只在使用 -O 或 -OO 選項時)
4.foo.pyc
5.foo.py
 
對於.py檔案,當一個模組第一次被匯入時,它就被彙編為位元組程式碼,並將位元組碼寫入一個同名的 .pyc檔案.後來的匯入操作會直接讀取.pyc檔案而不是.py檔案.(除非.py檔案的修改日期更新,這種情況會重新生成.pyc檔案) 在直譯器使用 -O 選項時，副檔名為.pyo的同名檔案被使用. pyo檔案的內容雖去掉行號,斷言,及其他除錯資訊的位元組碼，體積更小,執行速度更快.如果使用-OO選項代替-O,則文件字串也會在建立.pyo檔案時也被忽略.
如果在sys.path提供的所有路徑均查詢失敗,直譯器會繼續在內建模組中尋找,如果再次失敗，則引發 ImportError 異常. 
.pyc和.pyo檔案的彙編,當且僅當import 語句執行時進行. 
當 import 語句搜尋檔案時,檔名是大小寫敏感的。即使在檔案系統大小寫不敏感的系統上也是如此(Windows等). 這樣, import foo 只會匯入檔案foo.py而不會是FOO.PY.
 
重新匯入模組
如果更新了一個已經用import語句匯入的模組，內建函式reload()可以重新匯入並執行更新後的模組程式碼.它需要一個模組物件做為引數.例如: 
import foo
... some code ...
reload(foo)          # 重新匯入 foo
在reload()執行之後的針對模組的操作都會使用新匯入程式碼，不過reload()並不會更新使用舊模組建立的物件，因此有可能出現新舊版本物件共存的情況。 *注意* 使用C或C++編譯的模組不能通過 reload() 函式來重新匯入。記住一個原則，除非是在除錯和開發過程中，否則不要使用reload()函式.
 
2.包
多個關係密切的模組應該組織成一個包，以便於維護和使用。這項技術能有效避免名字空間衝突。建立一個名字為包名字的資料夾並在該資料夾下建立一個__init__.py 檔案就定義了一個包。你可以根據需要在該資料夾下存放資原始檔、已編譯擴充套件及子包。舉例來說，一個包可能有以下結構:
Graphics/
      __init__.py
      Primitive/
         __init__.py
         lines.py
         fill.py
         text.py
         ...
      Graph2d/
         __init__.py
         plot2d.py
         ...
      Graph3d/
         __init__.py
         plot3d.py
         ...
      Formats/
         __init__.py
         gif.py
         png.py
         tiff.py
         jpeg.py
 
import語句使用以下幾種方式匯入包中的模組: 
[python] view plain copy

1. import Graphics.Primitive.fill #匯入模組Graphics.Primitive.fill,只能以全名訪問模組屬性,例如 Graphics.Primitive.fill.floodfill(img,x,y,color).  
2. from Graphics.Primitive import fill# 匯入模組fill ,只能以 fill.屬性名這種方式訪問模組屬性,例如 fill.floodfill(img,x,y,color).  
3. from Graphics.Primitive.fill import floodfill #匯入模組fill ,並將函式floodfill放入當前名稱空間,直接訪問被匯入的屬性，例如 floodfill(img,x,y,color).  

1. import Graphics.Primitive.fill #匯入模組Graphics.Primitive.fill,只能以全名訪問模組屬性,例如 Graphics.Primitive.fill.floodfill(img,x,y,color).

2. from Graphics.Primitive import fill# 匯入模組fill ,只能以 fill.屬性名這種方式訪問模組屬性,例如 fill.floodfill(img,x,y,color).

3. from Graphics.Primitive.fill import floodfill #匯入模組fill ,並將函式floodfill放入當前名稱空間,直接訪問被匯入的屬性，例如 floodfill(img,x,y,color).

無論一個包的哪個部分被匯入, 在檔案__init__.py中的程式碼都會執行.這個檔案的內容允許為空,不過通常情況下它用來存放包的初始化程式碼。匯入過程遇到的所有 __init__.py檔案都被執行.因此 import Graphics.Primitive.fill 語句會順序執行 Graphics 和 Primitive 資料夾下的__init__.py檔案.

下邊這個語句具有歧義: 
[python] view plain copy

1. from Graphics.Primitive import *   

from Graphics.Primitive import * 

這個語句的原意圖是想將Graphics.Primitive包下的所有模組匯入到當前的名稱空間.然而,由於不同平臺間檔名規則不同(比如大小寫敏感問題), Python不能正確判定哪些模組要被匯入.這個語句只會順序執行 Graphics 和 Primitive 資料夾下的__init__.py檔案. 要解決這個問題，應該在Primitive資料夾下面的__init__.py中定義一個名字all的列表，例如:
[python] view plain copy

1. # Graphics/Primitive/__init__.py  
2. __all__ = ["lines","text","fill",...]  

1. # Graphics/Primitive/__init__.py

2. __all__ = ["lines","text","fill",...]

這樣,上邊的語句就可以匯入列表中所有模組.

下面這個語句只會執行Graphics目錄下的__init__.py檔案，而不會匯入任何模組: 
[python] view plain copy

1. import Graphics  
2. Graphics.Primitive.fill.floodfill(img,x,y,color)  # 失敗!  

1. import Graphics

2. Graphics.Primitive.fill.floodfill(img,x,y,color) # 失敗!

不過既然 import Graphics 語句會執行 Graphics 目錄下的 __init__..py檔案,我們就可以採取下面的手段來解決這個問題：

[python] view plain copy

1. # Graphics/__init__.py  
2. import Primitive, Graph2d, Graph3d  
3. # Graphics/Primitive/__init__.py  
4. import lines, fill, text, ...  

1. # Graphics/__init__.py

2. import Primitive, Graph2d, Graph3d

3. # Graphics/Primitive/__init__.py

4. import lines, fill, text, ...

這樣import Graphics語句就可以匯入所有的子模組(只能用全名來訪問這些模組的屬性).

sys.path 和sys.modules
sys.path包含了module的查詢路徑；
sys.modules包含了當前所load的所有的modules的dict（其中包含了builtin的modules）；