有關Python中的導包和子產品問題

一 .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()                 # 建立一個執行個體  

使用import spam 語句就可以将這個檔案作為子產品導入。系統在導入子產品時，要做以下三件事：

1.為源代碼檔案中定義的對象建立一個名字空間，通過這個名字空間可以通路到子產品中定義的函數及變量。

2.在新建立的名字空間裡執行源代碼檔案.

3.建立一個名為源代碼檔案的對象，該對象引用子產品的名字空間，這樣就可以通過這個對象通路子產品中的函數及變量，如：  

1. import spam           # 導入并運作子產品 spam  
2. print spam.a          # 通路子產品 spam 的屬性  
3. spam.foo()  
4. c = spam.bar()  

用逗号分割子產品名稱就可以同時導入多個子產品:

1. import socket, os, regex  

子產品導入時可以使用 as 關鍵字來改變子產品的引用對象名字:

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

使用from語句可以将子產品中的對象直接導入到目前的名字空間. from語句不建立一個到子產品名字空間的引用對象，而是把被導入子產品的一個或多個對象直接放入目前的名字空間:

1. from socket import gethostname # 将gethostname放如目前名字空間  
2. print gethostname()            # 直接調用  
3. socket.gethostname()           # 引發異常NameError: socket  

from語句支援逗号分割的對象，也可以使用星号(*)代表子產品中除下劃線開頭的所有對象:

1. from socket import gethostname, socket  
2. from socket import *   # 載入所有對象到目前名字空間  

不過，如果一個子產品如果定義有清單__all__，則from module import * 語句隻能導入__all__清單中存在的對象。

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

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

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

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

from module import * 語句隻能用于一個子產品的最頂層.*特别注意*：由于存在作用域沖突，不允許在函數中使用from 語句。 

每個子產品都擁有 __name__ 屬性，它是一個内容為子產品名字的字元串。最頂層的子產品名稱是 __main__ .指令行或是互動模式下程式都運作在__main__ 子產品内部. 利用__name__屬性，我們可以讓同一個程式在不同的場合（單獨執行或被導入)具有不同的行為，象下面這樣做：

1. # 檢查是單獨執行還是被導入  
2. if __name__ == '__main__':  
3.       # Yes  
4.       statements  
5. else:  
6.       # No (可能被作為子產品導入)  
7.       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/

         plot2d.py

      Graph3d/

         plot3d.py

      Formats/

         gif.py

         png.py

         tiff.py

         jpeg.py

import語句使用以下幾種方式導入包中的子產品:

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檔案.

下邊這個語句具有歧義:

1. from Graphics.Primitive import *   

這個語句的原意圖是想将Graphics.Primitive包下的所有子產品導入到目前的名稱空間.然而,由于不同平台間檔案名規則不同(比如大小寫敏感問題), Python不能正确判定哪些子產品要被導入.這個語句隻會順序運作 Graphics 和 Primitive 檔案夾下的__init__.py檔案. 要解決這個問題，應該在Primitive檔案夾下面的__init__.py中定義一個名字all的清單，例如:

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

這樣,上邊的語句就可以導入清單中所有子產品.

下面這個語句隻會執行Graphics目錄下的__init__.py檔案，而不會導入任何子產品:

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

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

1. # Graphics/__init__.py  
2. import Primitive, Graph2d, Graph3d