一、模塊

1、模塊和導(dǎo)入

當(dāng)程序代碼量變得相當(dāng)大、邏輯結(jié)構(gòu)變得非常復(fù)雜的時候，我們最好把代碼按照邏輯和功能劃分成一些有組織的代碼塊，并將其保存到一個個獨立的文件當(dāng)中。這些文件可以包含可執(zhí)行代碼、函數(shù)、類或者這些東西的組合，這些自我包含并且有組織的代碼塊就是模塊( module )。模塊是最高級別的 Python 代碼組織單元。

模塊往往對應(yīng)于物理機(jī)上的 Python 文件（或者是用外部語言如C、Java或C#編寫而成的擴(kuò)展）。當(dāng)你創(chuàng)建了一個 Python 源文件，其對應(yīng)的模塊的名字就是不帶 .py 后綴的文件名。一個模塊（Python程序文件）創(chuàng)建之后， 你可以從另一個文件中使用 import 語句導(dǎo)入這個模塊來使用，從而實現(xiàn)代碼的重用。這個把其他模塊附加到你的代碼中的操作叫做導(dǎo)入( import )。導(dǎo)入其他模塊之后就可以使用導(dǎo)入的模塊中定義的變量名。

2、模塊的作用

代碼重用

因為模塊對應(yīng)于 Python 文件，所以模塊中的代碼可以永久保存。你可以按照需要在代碼中任意次數(shù)的使用導(dǎo)入的模塊中定義的變量名（函數(shù)、類等），甚至可以重新導(dǎo)入模塊。除了作為最高級別的 Python 代碼組織單元，模塊（以及 模塊包）也是 Python 中程序代碼重用的最高層次。

系統(tǒng)命名空間的劃分

模塊還是定義變量名的空間，其內(nèi)部定義的變量名作為模塊的屬性，可以通過導(dǎo)入被多個外部的文件中的代碼引用。

模塊將變量名封裝進(jìn)了自己的命名空間，這一點對避免變量名的沖突很有幫助。所有的一切都存在于 ”模塊“ 中，可執(zhí)行的代碼以及創(chuàng)建的對象都毫無疑問的封裝在模塊之中。正式由于這一點，模塊是組織系統(tǒng)組件的天然工具。

實現(xiàn)共享服務(wù)和數(shù)據(jù)

從操作的角度來看，模塊對實現(xiàn)跨系統(tǒng)共享的組件是很方便的，只需要在不同的文件中導(dǎo)入相同的模塊即可。

3、Python 的程序架構(gòu)

一個 Python 程序通常都不僅僅涉及一個文件，一般都會采用多文件系統(tǒng)的形式。即使編寫單個文件，幾乎也一定會導(dǎo)入標(biāo)準(zhǔn)庫模塊或者使用到其他人已經(jīng)寫好的外部文件。

在 Python 中，頂層文件包含了程序的主要的控制流程：這就是你需要運行來啟動程序的文件。作為模塊被導(dǎo)入的文件通常在運行時不需要直接做任何事，它提供了頂層文件運行所需要的各種組件（普通變量、函數(shù)、類等）。頂層文件使用了在模塊文件中定義的組件，而這些模塊使用了其他模塊所定義的組件。

在 Python 中，一個文件導(dǎo)入了一個模塊來獲得這個模塊中定義的變量的訪問權(quán)，這些變量被認(rèn)作是這個模塊的屬性。導(dǎo)入的概念在 Python 之中貫穿始末。任何文件都能從任何其他文件中導(dǎo)入其變量，導(dǎo)入鏈要多深就有多深。

4、標(biāo)準(zhǔn)庫模塊

Python 自帶了很多實用的模塊，稱為標(biāo)準(zhǔn)鏈接庫。這個集合體大約有200多個模塊，包含與平臺不相關(guān)（不依賴于具體的系統(tǒng)，可以在任何系統(tǒng)上以同樣的方式調(diào)用，也就是說這些標(biāo)準(zhǔn)庫模塊是跨平臺的）的常見程序設(shè)計任務(wù)：操作系統(tǒng)接口、對象永久保存、文字模式匹配、網(wǎng)絡(luò)和 internet 腳本、GUI 建構(gòu)等。

這些工具都不是 Python 語言的組成部分，但是，你可以在任何安裝了 Python 的環(huán)境中，導(dǎo)入適當(dāng)?shù)哪K來使用。因為這些都是標(biāo)準(zhǔn)庫模，所以他們一定可以用，而且在執(zhí)行 Python 的絕大數(shù)平臺上都可以運行。

二、模塊的導(dǎo)入

模塊中的代碼會在首次導(dǎo)入時執(zhí)行，首先建立空的模塊對象，然后按照從頭到尾的順序，逐一執(zhí)行該模塊內(nèi)的語句。頂層（不在def或class之內(nèi)）的賦值語句（例如，=、def 和 class等）生成的變量會成為模塊對象的屬性，這些變量名會存儲在模塊的命名空間內(nèi)。模塊的命名空間能通過屬性 __dict__ 或內(nèi)建函數(shù) dir() 獲取。

1、模塊文件的命名

任何以 “.py” 為后綴名的 Python 文件都會被自動認(rèn)為是 Python 模塊，一般來說，Python 文件怎么命名都可以，但是如果打算將其作為模塊導(dǎo)入，文件必須以 ”.py“ 結(jié)尾。
對于會執(zhí)行但不會被導(dǎo)入的頂層文件而言，.py 后綴從技術(shù)上來說是可有可無的，但是每次都加上去，可以確保文件類型更醒目，并使其以后可以被導(dǎo)入到任何文件中。

因為模塊名在 Python 程序中會變成變量名（沒有.py）。因此Python文件應(yīng)該遵循普通變量名的命名規(guī)則。事實上，包導(dǎo)入中所用的模塊的文件名和目錄名都必須遵循變量名規(guī)則。

2、導(dǎo)入模塊的步驟

在Python中，導(dǎo)入并不是把一個文件文本插入另一個文件中。導(dǎo)入其實是運行時的運算，程序第一次導(dǎo)入指定文件時，會執(zhí)行三個步驟。
1、搜索找到模塊文件。
2、編譯成字節(jié)碼（需要時）。
3、執(zhí)行模塊的代碼來創(chuàng)建其所定義的對象，定義 import 語句所在文件的作用域的局部命名空間中的一個或多個變量名。

這三個步驟只在模塊第一次導(dǎo)入時才會執(zhí)行。在這之后，導(dǎo)入相同模塊時，會跳過這三個步驟，而只是提取內(nèi)存中已加載的模塊對象。這是有意而為之的，因為該操作開銷較大。如果你在模塊已加載后還需要再次導(dǎo)入（例如，為了支持終端用戶的定制），你就得通過調(diào)用 reload() 強(qiáng)制導(dǎo)入模塊。

從技術(shù)上講，Python 把載入的模塊存儲到一個名為 sys.modules 的表中，并在導(dǎo)入操作的開始檢查該表。如果模塊不存在，將會自動執(zhí)行上面的三個步驟。

搜索

Python 會遍歷模塊搜索路徑，查找 import 語句所引用的模塊文件。在導(dǎo)入者文件中，只能列出要導(dǎo)入的模塊文件的簡單名稱，路徑和后綴是刻意省略掉的。

當(dāng)一個模塊被導(dǎo)入時，Python 會把程序內(nèi)部的模塊名映射到外部物理環(huán)境中的文件名，也就是將模塊搜索路徑中的目錄路徑添加在模塊名前邊，并在模塊名的后邊添加 .py 或其他后綴名。

編譯

找到模塊文件后，Python 會查找對應(yīng)的 .pyc 字節(jié)碼文件。如果沒有字節(jié)碼文件，Python 會將模塊文件編譯成字節(jié)碼文件。如果找到對應(yīng)的字節(jié)碼文件，Python 會檢查文件的時間戳，如果發(fā)現(xiàn)字節(jié)碼文件比模塊文件舊（例如，如果你修改過源文件），就會重新編譯模塊文件生成新的字節(jié)碼文件。如果字節(jié)碼文件不比對應(yīng)的 .py 源代碼文件舊，就會跳過源代碼到字節(jié)碼的編譯步驟。

如果 Python 在搜索路徑上只發(fā)現(xiàn)了字節(jié)碼文件，而沒有源代碼，就會直接加載字節(jié)碼文件（這意味著你可以把一個程序只作為字節(jié)碼文件發(fā)布，而避免發(fā)送源代碼）。換句話說，直接使用字節(jié)碼文件跳過編譯步驟，會提高程序的啟動提速。

通常不會看見程序頂層文件的 .pyc 字節(jié)碼文件，除非這個文件也別其他文件導(dǎo)入：只有被導(dǎo)入的文件才會在機(jī)器上留下 .pyc 。頂層文件的字節(jié)碼是在內(nèi)部使用后就丟棄了，被導(dǎo)入文件的字節(jié)碼則保存在文件中從而可以提高之后導(dǎo)入的速度。

頂層文件通常是設(shè)計成直接執(zhí)行，而不是被導(dǎo)入的。

運行

import 操作的最后步驟是執(zhí)行模塊的字節(jié)碼。文件中所有語句會從頭到尾依次執(zhí)行，而此步驟中任何對變量名的賦值運算，都會產(chǎn)生模塊文件的屬性。因此，這個執(zhí)行步驟會生成模塊代碼所定義的所有工具。

因為最后的導(dǎo)入步驟實際上是執(zhí)行文件的程序代碼，如果模塊文件中任何頂層代碼確實做什么實際的工作，你就會在導(dǎo)入時看見其結(jié)果。

3、import 語句

常見的 import 導(dǎo)入語句可以分為兩種：單獨的 import 語句用來導(dǎo)入模塊名；帶有
from 的 import 語句用來導(dǎo)入模塊中的變量名，同時可以使用 * 號導(dǎo)入模塊中的所有變量。在以上兩種語句中，我們都可以使用 as 語句為導(dǎo)入的模塊或變量指定別名。當(dāng)語句包含多個子句（以逗號分隔）時，為每個子句分別執(zhí)行模塊導(dǎo)入的三個步驟，就像子句已被分隔為單獨的 import 語句一樣。

如果導(dǎo)入的模塊被成功檢索到，它將通過以下三種方式之一綁定到本地命名空間：

• 如果模塊名后面是 as，則 as 之后的變量名將在本地命名空間中綁定為對導(dǎo)入的模塊對象的引用。
• 如果未指定其他名稱，并且正在導(dǎo)入的模塊是頂級模塊（），則模塊的名稱將在本地命名空間中綁定為對導(dǎo)入模塊對象的引用。
• 如果正在導(dǎo)入的模塊不是頂級模塊，則包含該模塊的頂級包的名稱在本地命名空間中被綁定為對頂級包的引用。導(dǎo)入的模塊必須使用其完全限定名稱而不能直接訪問。包的概念會在后續(xù)章節(jié)介紹。

from 形式會多一些復(fù)雜的過程：

1. 找到 from 子句中指定的模塊，如果需要，加載和初始化它；
2. 對于 import 子句中指定的每個標(biāo)識符：
   a. 檢查導(dǎo)入的模塊是否具有該名稱的屬性；
   b. 如果沒有，請嘗試導(dǎo)入具有該名稱的子模塊，然后再次檢查導(dǎo)入的模塊的該屬性；
   c. 如果未找到該屬性，則引發(fā) ImportError；
   d. 如果找到該名稱的屬性，對該屬性的引用存儲在本地命名空間中，使用 as 子句中的名稱（如果存在），否則使用屬性名稱；

如果在 from 語句中 import 后面的標(biāo)識符列表被替換為星號（*），則模塊中定義的所有公共名稱都在 import 語句所在的作用域的本地命名空間中綁定。

（1）import 形式

import 語句將模塊導(dǎo)入文件中：
import module_name

import 是可執(zhí)行語句，就像 def 一樣，它是隱性的賦值語句。當(dāng) Python 執(zhí)行到這個語句時，會將導(dǎo)入生成的模塊對象賦值給 import 語句后面的模塊名，而模塊文件頂層對任意類型賦值了的變量名，都會產(chǎn)生為模塊對象的屬性。

一旦導(dǎo)入完成，一個模塊的屬性（函數(shù)和變量）可以通過熟悉的 （. ）句點屬性標(biāo)識法訪問。
module.function()
module.variable

import 語句組合兩個操作；它搜索指定的模塊并根據(jù)需要執(zhí)行模塊以得到模塊對象，然后將模塊對象綁定到本地作用域中的模塊名。

import 語句的搜索操作被定義為：使用適當(dāng)?shù)膮?shù)調(diào)用 __import__() 函數(shù)。直接調(diào)用 __import__() 只執(zhí)行模塊搜索，如果找到，則執(zhí)行模塊創(chuàng)建操作，并返回模塊對象。如果找不到指定的模塊，則會引發(fā) ImportError。雖然可能會伴隨著某些其他的操作，例如導(dǎo)入父包以及更新各種緩存（包括sys.modules），但只有 import 語句會執(zhí)行名稱綁定操作。

屬性名的點號運算

在 Python 之中，可以使用點號運算語法 object.attribute 獲取任意的 object 的attribute 屬性。

點號運算符其實就是表達(dá)式，傳回和對象相配的屬性名的值。當(dāng)使用點號運算符來讀取變量名時，就把明確的對象提供給 Python ， LEGB 規(guī)則只適用于無點號運算的純變量名。

簡單變量名

X 是指在當(dāng)前作用域內(nèi)搜索變量名 X（遵循LEGB規(guī)則）

點號運算

X，Y 是指在當(dāng)前范圍內(nèi)搜索 X，然后搜索對象 X 之中的屬性 Y（而非在作用域里）。

多層點號運算

X，Y，Z 指的是在當(dāng)前范圍內(nèi)搜索 X，然后搜索對象 X 之中的屬性 Y，然后在對象X.Y 中搜索屬性 Z 。

通用性

點號運算可用于任何具有屬性的對象：模塊、類、C 擴(kuò)展類型等。

（2）from - import 形式

使用 from-import 語句可以將模塊的屬性導(dǎo)入到當(dāng)前作用域，并綁定到指定的變量名。
from module import name1[, name2[,... nameN]]

from 的第一步驟也是普通的導(dǎo)入操作。因此，from 總是會把整個模塊導(dǎo)入到內(nèi)存中（如果還沒被導(dǎo)入的話），無論是從這個文件中復(fù)制出多少變量名。只加載模塊文件的一部分（例如，一個函數(shù)）是不可能的。但是因為模塊在 Python 之中是字節(jié)碼而不是機(jī)器碼，通常可以忽略效率的問題。

from 語句潛在的陷阱

因為 from 語句會讓變量位置更隱秘和模糊，所以 form 語句可能會破壞命名空間。如果使用 from 導(dǎo)入變量，而那些變量碰巧和作用域中現(xiàn)有變量同名，變量就會被悄悄地覆蓋掉。使用簡單的 import 語句就不會有這種問題，因為你一定得通過模塊名才能獲取其屬性（變量名）。不過使用 from 時，只要你了解并預(yù)料到可能發(fā)生這種事，在實際情況下這就不是一個大問題了，尤其當(dāng)你明確列出導(dǎo)入的變量名時（例如，from moudle import a, b, c）。

和 reload 調(diào)用同時使用時，from 語句有比較嚴(yán)重的問題，因為導(dǎo)入的變量名可能引用之前導(dǎo)入的對象。

簡單模塊一般傾向于使用 import，而不是 from。多數(shù)的 from 語句是用于明確列舉出想要的變量，而且限制在每個文件中只用一次 from * 形式。當(dāng)你必須使用兩個不同模塊內(nèi)定義的相同的變量名時，才真的必須使用 import，這種情況下不能用 from（當(dāng)然你可以在 from 語句中使用 as 語句來個規(guī)避變量名沖突的問題）。

（3）from - import * 形式

從一個模塊導(dǎo)入許多變量名時，import 行會越來越長，直到自動換行，而且我們需要使用反斜杠字符 \ 讓一條語句橫跨多行 。

from module import name1, name2, name3, name4,\
   name5, name6, name7

你可以選擇使用多行的 from-import 語句：

from module import name1, name2, name3, name4
from module import name5, name6, name7

核心風(fēng)格: 限制使用 " from - import * "

在實踐中, 我們認(rèn)為 "from - import *" 不是良好的編程風(fēng)格，因為它"污染"當(dāng)前名稱空間，讓變量名難以理解。而且很可能覆蓋當(dāng)前名稱空間中現(xiàn)有的名字，尤其是在導(dǎo)入一個以上的模塊時。事實上，from * 形式會把一個命名空間融入到另一個，所以會使得模塊的命名空間的分割特性失效。

如果某個模塊有很多要經(jīng)常訪問的變量或者模塊的名字很長，這也不失為一個方便的好辦法。我們只在兩種場合下建議使用這樣的方法，一個場合是：要使用的目標(biāo)模塊中的屬性非常多，反復(fù)鍵入模塊名很不方便，例如 Tkinter (Python/Tk) 和 NumPy (Numeric Python) 模塊，可能還有 socket 模塊。另一個場合是在交互解釋器下，因為這樣可以減少輸入次數(shù)。

一般情況下，我們不提倡使用不再流行的 from module import * 語句 。真正的 Python 程序員應(yīng)該使用 Python 的標(biāo)準(zhǔn)分組機(jī)制(圓括號)來創(chuàng)建更合理更明確的多行導(dǎo)入語句。

最小化 from * 的破壞：_x 和 __all__

把下劃線放在變量名前面（例如，_x），可以防止客戶端使用 from * 語句導(dǎo)入模塊名時，把其中的那些變量名復(fù)制出去。這其實是為了對命名空間的破壞最小化而已。下劃線不是私有變量的聲明：你還是可以使用其他導(dǎo)入形式看見并修改這類變量名。

使用此功能時，from * 語句只會把列在 __all__ 列表中的這些變量名賦值出來。事實上這和 x 慣例相反 __all時指出要復(fù)制的變量名，而_x 是指出不被復(fù)制的變量名。Python 會先尋找模塊內(nèi)的 __all_ 列表；如果沒有定義的話，from * 就會復(fù)制出開頭沒有單下劃線的所有變量名。

就像 _x 慣例一樣，__all__ 列表只對 from * 語句這種形式有效，它并不是私有聲明。

（4）擴(kuò)展的導(dǎo)入語句（as）

有時候你導(dǎo)入的模塊名或是模塊屬性名稱已經(jīng)在你的程序中使用了，或者你不想使用導(dǎo)入的名字，可能是它太長不便輸入什么的。 這已經(jīng)成為 Python 程序員的一個普遍需求：使用自己想要的名字替換模塊的原始名稱。使用擴(kuò)展的 as 子句，你就可以在導(dǎo)入的同時指定局部綁定名稱。

import 語句和 from 語句都可以擴(kuò)展，讓模塊可以在腳本中給予不同的變量名。

import modulename as name
相當(dāng)于：
import modulename
name = modulename
del modulename

from modulename import attrname as name
相當(dāng)于：
from modulename import attrname
name = attrname
del attrname

這個擴(kuò)展功能很常用，替代變量名較長的變量提供簡短一些的同義詞，而且當(dāng)已在腳本中使用一個變量名使得執(zhí)行普通 import 語句會被覆蓋時，使用 as，就可避免變量名沖突。

4、模塊重載

在同一個進(jìn)程中模塊只在第一次導(dǎo)入時，加載和執(zhí)行該模塊的代碼。之后的導(dǎo)入只會使用已加載的模塊對象，而不會重載或重新執(zhí)行文件的代碼。要強(qiáng)制使模塊重新載入并重新運行，可以使用 reload() 函數(shù)。

reload()

reload() 函數(shù)位于Python中的 imp 模塊內(nèi)，使用前必須先導(dǎo)入。它會強(qiáng)制已加載的模塊的代碼重新載入并重新執(zhí)行。因為 reload() 期望得到的是對象，在重載之前，模塊一定是已經(jīng)預(yù)先成功導(dǎo)入了。

重新執(zhí)行模塊文件的代碼會覆蓋其現(xiàn)有的命名空間。重載會影響所有使用 import 導(dǎo)入模塊的程序，因為使用 import 的程序需要通過點號運算符取出屬性，在重載后，使用的模塊對象變成了新的值。重載只會對重載后使用 from 語句導(dǎo)入模塊的程序造成影響。之前使用 from 來讀取屬性的客戶端并不會受到重載的影響，那些程序引用的依然是重載前所取出的舊對象。

reload() 函數(shù)使得可以修改模塊程序的一些代碼，而無須停止整個程序。因此，利用reload() ，可以立即看到對模塊的修改效果。重載無法用于每種情況，但是能用時，可縮短開發(fā)的流程。一般的用法是：導(dǎo)入一個模塊，在文本編輯器內(nèi)修改其源代碼，然后將其重載。當(dāng)調(diào)用 reload() 時，Python 會重讀模塊文件的源代碼，重新執(zhí)行其頂層語句。

因為 Python 是解釋性的（或多或少），其實已經(jīng)避免了類似 C 語言程序執(zhí)行時所需的編譯連接步驟：在執(zhí)行程序?qū)霑r，模塊會動態(tài)加載。重載進(jìn)一步的提供了性能優(yōu)勢，讓你可以修改執(zhí)行中的程序的一部分，而不需要中止。注意：reload() 當(dāng)前只能用在Python 編寫的模塊；用 C 這類語言編寫的編譯后的擴(kuò)展模塊也可在執(zhí)行中動態(tài)加載，但無法重載。

《Python基礎(chǔ)手冊》系列：

Python基礎(chǔ)手冊 1 —— Python語言介紹
Python基礎(chǔ)手冊 2 —— Python 環(huán)境搭建（Linux）
Python基礎(chǔ)手冊 3 —— Python解釋器
Python基礎(chǔ)手冊 4 —— 文本結(jié)構(gòu)
Python基礎(chǔ)手冊 5 —— 標(biāo)識符和關(guān)鍵字
Python基礎(chǔ)手冊 6 —— 操作符
Python基礎(chǔ)手冊 7 —— 內(nèi)建函數(shù)
Python基礎(chǔ)手冊 8 —— Python對象
Python基礎(chǔ)手冊 9 —— 數(shù)字類型
Python基礎(chǔ)手冊10 —— 序列（字符串）
Python基礎(chǔ)手冊11 —— 序列（元組&列表）
Python基礎(chǔ)手冊12 —— 序列（類型操作）
Python基礎(chǔ)手冊13 —— 映射（字典）
Python基礎(chǔ)手冊14 —— 集合
Python基礎(chǔ)手冊15 —— 解析
Python基礎(chǔ)手冊16 —— 文件
Python基礎(chǔ)手冊17 —— 簡單語句
Python基礎(chǔ)手冊18 —— 復(fù)合語句（流程控制語句）
Python基礎(chǔ)手冊19 —— 迭代器
Python基礎(chǔ)手冊20 —— 生成器
Python基礎(chǔ)手冊21 —— 函數(shù)的定義
Python基礎(chǔ)手冊22 —— 函數(shù)的參數(shù)
Python基礎(chǔ)手冊23 —— 函數(shù)的調(diào)用
Python基礎(chǔ)手冊24 —— 函數(shù)中變量的作用域
Python基礎(chǔ)手冊25 —— 裝飾器
Python基礎(chǔ)手冊26 —— 錯誤 & 異常
Python基礎(chǔ)手冊27 —— 模塊
Python基礎(chǔ)手冊28 —— 模塊的高級概念
Python基礎(chǔ)手冊29 —— 包