一、模塊
1、模塊和導入
當程序代碼量變得相當大、邏輯結構變得非常復雜的時(shí)候，我們最好把代碼按照邏輯和功能劃分成一些有組織的代碼塊，并將其保存到一個(gè)個(gè)獨立的文件當中。這些文件可以包含可執行代碼、函數、類(lèi)或者這些東西的組合，這些自我包含并且有組織的代碼塊就是 模塊 ( module )。模塊是最高級別的 Python 代碼組織單元。
模塊往往對應于物理機上的 Python 文件（或者是用外部語(yǔ)言如C、Java或C#編寫(xiě)而成的擴展）。當你創(chuàng )建了一個(gè) Python 源文件，其對應的模塊的名字就是不帶 .py 后綴的文件名。一個(gè)模塊（Python程序文件）創(chuàng )建之后， 你可以從另一個(gè)文件中使用 import 語(yǔ)句導入這個(gè)模塊來(lái)使用，從而實(shí)現代碼的重用。這個(gè)把其他模塊附加到你的代碼中的操作叫做 導入 ( import )。導入其他模塊之后就可以使用導入的模塊中定義的變量名。
2、模塊的作用
代碼重用
因為模塊對應于 Python 文件，所以模塊中的代碼可以永久保存。你可以按照需要在代碼中任意次數的使用導入的模塊中定義的變量名（函數、類(lèi)等），甚至可以重新導入模塊。除了作為最高級別的 Python 代碼組織單元，模塊（以及 模塊包）也是 Python 中程序代碼重用的最高層次。
系統命名空間的劃分
模塊還是定義變量名的空間，其內部定義的變量名作為模塊的屬性，可以通過(guò)導入被多個(gè)外部的文件中的代碼引用。
模塊將變量名封裝進(jìn)了自己的命名空間，這一點(diǎn)對避免變量名的沖突很有幫助。所有的一切都存在于 ”模塊“ 中，可執行的代碼以及創(chuàng )建的對象都毫無(wú)疑問(wèn)的封裝在模塊之中。正式由于這一點(diǎn)，模塊是組織系統組件的天然工具。
實(shí)現共享服務(wù)和數據
從操作的角度來(lái)看，模塊對實(shí)現跨系統共享的組件是很方便的，只需要在不同的文件中導入相同的模塊即可。
3、Python 的程序架構
一個(gè) Python 程序通常都不僅僅涉及一個(gè)文件，一般都會(huì )采用多文件系統的形式。即使編寫(xiě)單個(gè)文件，幾乎也一定會(huì )導入標準庫模塊或者使用到其他人已經(jīng)寫(xiě)好的外部文件。
一般來(lái)講一個(gè)完整的程序由啟動(dòng)運行的腳本文件以及零個(gè)或多個(gè)作為支持（用作導入）的文件組成。
在 Python 中，頂層文件包含了程序的主要的控制流程：這就是你需要運行來(lái)啟動(dòng)程序的文件。作為模塊被導入的文件通常在運行時(shí)不需要直接做任何事，它提供了頂層文件運行所需要的各種組件（普通變量、函數、類(lèi)等）。頂層文件使用了在模塊文件中定義的組件，而這些模塊使用了其他模塊所定義的組件。
在 Python 中，一個(gè)文件導入了一個(gè)模塊來(lái)獲得這個(gè)模塊中定義的變量的訪(fǎng)問(wèn)權，這些變量被認作是這個(gè)模塊的屬性。導入的概念在 Python 之中貫穿始末。任何文件都能從任何其他文件中導入其變量，導入鏈要多深就有多深。
4、標準庫模塊
Python 自帶了很多實(shí)用的模塊，稱(chēng)為標準鏈接庫。這個(gè)集合體大約有200多個(gè)模塊，包含與平臺不相關(guān)（不依賴(lài)于具體的系統，可以在任何系統上以同樣的方式調用，也就是說(shuō)這些標準庫模塊是跨平臺的）的常見(jiàn)程序設計任務(wù)：操作系統接口、對象永久保存、文字模式匹配、網(wǎng)絡(luò )和 internet 腳本、GUI 建構等。
這些工具都不是 Python 語(yǔ)言的組成部分，但是，你可以在任何安裝了 Python 的環(huán)境中，導入適當的模塊來(lái)使用。因為這些都是標準庫模，所以他們一定可以用，而且在執行 Python 的絕大數平臺上都可以運行。
二、模塊的導入
模塊中的代碼會(huì )在首次導入時(shí)執行，首先建立空的模塊對象，然后按照從頭到尾的順序，逐一執行該模塊內的語(yǔ)句。頂層（不在def或class之內）的賦值語(yǔ)句（例如，=、def 和 class等）生成的變量會(huì )成為模塊對象的屬性，這些變量名會(huì )存儲在模塊的命名空間內。模塊的命名空間能通過(guò)屬性 __dict__ 或內建函數 dir() 獲取。
1、模塊文件的命名
任何以 “.py” 為后綴名的 Python 文件都會(huì )被自動(dòng)認為是 Python 模塊，一般來(lái)說(shuō)，Python 文件怎么命名都可以，但是如果打算將其作為模塊導入，文件必須以 ”.py“ 結尾。
對于會(huì )執行但不會(huì )被導入的頂層文件而言，.py 后綴從技術(shù)上來(lái)說(shuō)是可有可無(wú)的，但是每次都加上去，可以確保文件類(lèi)型更醒目，并使其以后可以被導入到任何文件中。
因為模塊名在 Python 程序中會(huì )變成變量名（沒(méi)有.py）。因此Python文件應該遵循普通變量名的命名規則。事實(shí)上，包導入中所用的模塊的文件名和目錄名都必須遵循變量名規則。
2、導入模塊的步驟
在Python中，導入并不是把一個(gè)文件文本插入另一個(gè)文件中。導入其實(shí)是運行時(shí)的運算，程序第一次導入指定文件時(shí)，會(huì )執行三個(gè)步驟。
1、搜索找到模塊文件。
2、編譯成字節碼（需要時(shí)）。
3、執行模塊的代碼來(lái)創(chuàng )建其所定義的對象，定義 import 語(yǔ)句所在文件的作用域的局部命名空間中的一個(gè)或多個(gè)變量名。
這三個(gè)步驟只在模塊第一次導入時(shí)才會(huì )執行。在這之后，導入相同模塊時(shí)，會(huì )跳過(guò)這三個(gè)步驟，而只是提取內存中已加載的模塊對象。這是有意而為之的，因為該操作開(kāi)銷(xiāo)較大。如果你在模塊已加載后還需要再次導入（例如，為了支持終端用戶(hù)的定制），你就得通過(guò)調用 reload() 強制導入模塊。
從技術(shù)上講，Python 把載入的模塊存儲到一個(gè)名為 sys.modules 的表中，并在導入操作的開(kāi)始檢查該表。如果模塊不存在，將會(huì )自動(dòng)執行上面的三個(gè)步驟。
搜索
Python 會(huì )遍歷模塊搜索路徑，查找 import 語(yǔ)句所引用的模塊文件。在導入者文件中，只能列出要導入的模塊文件的簡(jiǎn)單名稱(chēng)，路徑和后綴是刻意省略掉的。
當一個(gè)模塊被導入時(shí)，Python 會(huì )把程序內部的模塊名映射到外部物理環(huán)境中的文件名，也就是將模塊搜索路徑中的目錄路徑添加在模塊名前邊，并在模塊名的后邊添加 .py 或其他后綴名。
編譯
找到模塊文件后，Python 會(huì )查找對應的 .pyc 字節碼文件。如果沒(méi)有字節碼文件，Python 會(huì )將模塊文件編譯成字節碼文件。如果找到對應的字節碼文件，Python 會(huì )檢查文件的時(shí)間戳，如果發(fā)現字節碼文件比模塊文件舊（例如，如果你修改過(guò)源文件），就會(huì )重新編譯模塊文件生成新的字節碼文件。如果字節碼文件不比對應的 .py 源代碼文件舊，就會(huì )跳過(guò)源代碼到字節碼的編譯步驟。
如果 Python 在搜索路徑上只發(fā)現了字節碼文件，而沒(méi)有源代碼，就會(huì )直接加載字節碼文件（這意味著(zhù)你可以把一個(gè)程序只作為字節碼文件發(fā)布，而避免發(fā)送源代碼）。換句話(huà)說(shuō)，直接使用字節碼文件跳過(guò)編譯步驟，會(huì )提高程序的啟動(dòng)提速。
通常不會(huì )看見(jiàn)程序頂層文件的 .pyc 字節碼文件，除非這個(gè)文件也別其他文件導入：只有被導入的文件才會(huì )在機器上留下 .pyc 。頂層文件的字節碼是在內部使用后就丟棄了，被導入文件的字節碼則保存在文件中從而可以提高之后導入的速度。
頂層文件通常是設計成直接執行，而不是被導入的。
運行
import 操作的最后步驟是執行模塊的字節碼。文件中所有語(yǔ)句會(huì )從頭到尾依次執行，而此步驟中任何對變量名的賦值運算，都會(huì )產(chǎn)生模塊文件的屬性。因此，這個(gè)執行步驟會(huì )生成模塊代碼所定義的所有工具。
因為最后的導入步驟實(shí)際上是執行文件的程序代碼，如果模塊文件中任何頂層代碼確實(shí)做什么實(shí)際的工作，你就會(huì )在導入時(shí)看見(jiàn)其結果。
3、import 語(yǔ)句
常見(jiàn)的 import 導入語(yǔ)句可以分為兩種：?jiǎn)为毜?import 語(yǔ)句用來(lái)導入模塊名；帶有
from 的 import 語(yǔ)句用來(lái)導入模塊中的變量名，同時(shí)可以使用 * 號導入模塊中的所有變量。在以上兩種語(yǔ)句中，我們都可以使用 as 語(yǔ)句為導入的模塊或變量指定別名。當語(yǔ)句包含多個(gè)子句（以逗號分隔）時(shí)，為每個(gè)子句分別執行模塊導入的三個(gè)步驟，就像子句已被分隔為單獨的 import 語(yǔ)句一樣。
如果導入的模塊被成功檢索到，它將通過(guò)以下三種方式之一綁定到本地命名空間：
如果模塊名后面是as，則 as 之后的變量名將在本地命名空間中綁定為對導入的模塊對象的引用。
如果未指定其他名稱(chēng)，并且正在導入的模塊是頂級模塊（），則模塊的名稱(chēng)將在本地命名空間中綁定為對導入模塊對象的引用。
如果正在導入的模塊不是頂級模塊，則包含該模塊的頂級包的名稱(chēng)在本地命名空間中被綁定為對頂級包的引用。導入的模塊必須使用其完全限定名稱(chēng)而不能直接訪(fǎng)問(wèn)。包的概念會(huì )在后續章節介紹。
from 形式會(huì )多一些復雜的過(guò)程：
找到 from 子句中指定的模塊，如果需要，加載和初始化它；
對于 import 子句中指定的每個(gè)標識符：
a. 檢查導入的模塊是否具有該名稱(chēng)的屬性；
b. 如果沒(méi)有，請嘗試導入具有該名稱(chēng)的子模塊，然后再次檢查導入的模塊的該屬性；
c. 如果未找到該屬性，則引發(fā) ImportError；
d. 如果找到該名稱(chēng)的屬性，對該屬性的引用存儲在本地命名空間中，使用 as 子句中的名稱(chēng)（如果存在），否則使用屬性名稱(chēng)；
如果在 from 語(yǔ)句中 import 后面的標識符列表被替換為星號（*），則模塊中定義的所有公共名稱(chēng)都在 import 語(yǔ)句所在的作用域的本地命名空間中綁定。
（1）import 形式
import 語(yǔ)句將模塊導入文件中：
import module_name
import 是可執行語(yǔ)句，就像 def 一樣，它是隱性的賦值語(yǔ)句。當 Python 執行到這個(gè)語(yǔ)句時(shí)，會(huì )將導入生成的模塊對象賦值給 import 語(yǔ)句后面的模塊名，而模塊文件頂層對任意類(lèi)型賦值了的變量名，都會(huì )產(chǎn)生為模塊對象的屬性。
一旦導入完成，一個(gè)模塊的屬性（函數和變量）可以通過(guò)熟悉的 （. ）句點(diǎn)屬性標識法訪(fǎng)問(wèn)。
module.function()
module.variable
import 語(yǔ)句組合兩個(gè)操作；它搜索指定的模塊并根據需要執行模塊以得到模塊對象，然后將模塊對象綁定到本地作用域中的模塊名。
import 語(yǔ)句的搜索操作被定義為：使用適當的參數調用 __import__() 函數。直接調用 __import__() 只執行模塊搜索，如果找到，則執行模塊創(chuàng )建操作，并返回模塊對象。如果找不到指定的模塊，則會(huì )引發(fā) ImportError。雖然可能會(huì )伴隨著(zhù)某些其他的操作，例如導入父包以及更新各種緩存（包括sys.modules），但只有 import 語(yǔ)句會(huì )執行名稱(chēng)綁定操作。
屬性名的點(diǎn)號運算
在 Python 之中，可以使用點(diǎn)號運算語(yǔ)法 object.attribute 獲取任意的 object 的attribute 屬性。
點(diǎn)號運算符其實(shí)就是表達式，傳回和對象相配的屬性名的值。當使用點(diǎn)號運算符來(lái)讀取變量名時(shí)，就把明確的對象提供給 Python ， LEGB 規則只適用于無(wú)點(diǎn)號運算的純變量名。
簡(jiǎn)單變量名
X 是指在當前作用域內搜索變量名 X（遵循LEGB規則）
點(diǎn)號運算
X，Y 是指在當前范圍內搜索 X，然后搜索對象 X 之中的屬性 Y（而非在作用域里）。
多層點(diǎn)號運算
X，Y，Z 指的是在當前范圍內搜索 X，然后搜索對象 X 之中的屬性 Y，然后在對象X.Y 中搜索屬性 Z 。
通用性
點(diǎn)號運算可用于任何具有屬性的對象：模塊、類(lèi)、C 擴展類(lèi)型等。
（2）from - import 形式
使用 from-import 語(yǔ)句可以將模塊的屬性導入到當前作用域，并綁定到指定的變量名。
from module import name1[, name2[,... nameN]]
和 import 一樣，from - import 語(yǔ)句也是可執行的隱性賦值語(yǔ)句。import 將導入的模塊對象賦值給一個(gè)模塊名。而 from - import 將模塊中的一個(gè)或多個(gè)變量（也就是生成的模塊對象的一個(gè)或多個(gè)屬性）綁定到當前文件中 import 語(yǔ)句指定的變量名。因為 from 會(huì )把模塊中定義的變量名復制到另一個(gè)文件的作用域中，所以它就可以讓我們直接在另一個(gè)文件中直接使用從模塊中導入的變量名，而不需要通過(guò)模塊名。（例如：variate）
from 的第一步驟也是普通的導入操作。因此，from 總是會(huì )把整個(gè)模塊導入到內存中（如果還沒(méi)被導入的話(huà)），無(wú)論是從這個(gè)文件中復制出多少變量名。只加載模塊文件的一部分（例如，一個(gè)函數）是不可能的。但是因為模塊在 Python 之中是字節碼而不是機器碼，通?？梢院雎孕实膯?wèn)題。
from 語(yǔ)句潛在的陷阱
因為 from 語(yǔ)句會(huì )讓變量位置更隱秘和模糊，所以 form 語(yǔ)句可能會(huì )破壞命名空間。如果使用 from 導入變量，而那些變量碰巧和作用域中現有變量同名，變量就會(huì )被悄悄地覆蓋掉。使用簡(jiǎn)單的 import 語(yǔ)句就不會(huì )有這種問(wèn)題，因為你一定得通過(guò)模塊名才能獲取其屬性（變量名）。不過(guò)使用 from 時(shí)，只要你了解并預料到可能發(fā)生這種事，在實(shí)際情況下這就不是一個(gè)大問(wèn)題了，尤其當你明確列出導入的變量名時(shí)（例如，from moudle import a, b, c）。
和 reload 調用同時(shí)使用時(shí)，from 語(yǔ)句有比較嚴重的問(wèn)題，因為導入的變量名可能引用之前導入的對象。
簡(jiǎn)單模塊一般傾向于使用 import，而不是 from。多數的 from 語(yǔ)句是用于明確列舉出想要的變量，而且限制在每個(gè)文件中只用一次 from * 形式。當你必須使用兩個(gè)不同模塊內定義的相同的變量名時(shí)，才真的必須使用 import，這種情況下不能用 from（當然你可以在 from 語(yǔ)句中使用 as 語(yǔ)句來(lái)個(gè)規避變量名沖突的問(wèn)題）。
（3）from - import * 形式
從一個(gè)模塊導入許多變量名時(shí)，import 行會(huì )越來(lái)越長(cháng)，直到自動(dòng)換行，而且我們需要使用反斜杠字符 讓一條語(yǔ)句橫跨多行 。
from module import name1, name2, name3, name4,ame5, name6, name7
你可以選擇使用多行的 from-import 語(yǔ)句：
from module import name1, name2, name3, name4from module import name5, name6, name7
在 from 語(yǔ)句的 import 子句中，當我們使用 * 時(shí)，會(huì )取得模塊頂層所有賦值的變量名的拷貝。從根本上來(lái)說(shuō)，這就是把一個(gè)模塊的命名空間融入另一個(gè)模塊之中；同樣地，實(shí)際效果就是可以讓我們少輸入一些代碼。from * 語(yǔ)句形式只能用在一個(gè)模塊文件的頂部，嘗試在類(lèi)或函數定義中使用它將引發(fā) SyntaxError。
核心風(fēng)格: 限制使用 " from - import * "
在實(shí)踐中, 我們認為 "from - import *" 不是良好的編程風(fēng)格，因為它"污染"當前名稱(chēng)空間，讓變量名難以理解。而且很可能覆蓋當前名稱(chēng)空間中現有的名字，尤其是在導入一個(gè)以上的模塊時(shí)。事實(shí)上，from * 形式會(huì )把一個(gè)命名空間融入到另一個(gè)，所以會(huì )使得模塊的命名空間的分割特性失效。
如果某個(gè)模塊有很多要經(jīng)常訪(fǎng)問(wèn)的變量或者模塊的名字很長(cháng)，這也不失為一個(gè)方便的好辦法。我們只在兩種場(chǎng)合下建議使用這樣的方法，一個(gè)場(chǎng)合是：要使用的目標模塊中的屬性非常多，反復鍵入模塊名很不方便，例如 Tkinter (Python/Tk) 和 NumPy (Numeric Python) 模塊，可能還有 socket 模塊。另一個(gè)場(chǎng)合是在交互解釋器下，因為這樣可以減少輸入次數。
一般情況下，我們不提倡使用不再流行的 from module import * 語(yǔ)句 。真正的 Python 程序員應該使用 Python 的標準分組機制(圓括號)來(lái)創(chuàng )建更合理更明確的多行導入語(yǔ)句。
最小化 from * 的破壞：_x 和 __all__
把下劃線(xiàn)放在變量名前面（例如，_x），可以防止客戶(hù)端使用 from * 語(yǔ)句導入模塊名時(shí)，把其中的那些變量名復制出去。這其實(shí)是為了對命名空間的破壞最小化而已。下劃線(xiàn)不是私有變量的聲明：你還是可以使用其他導入形式看見(jiàn)并修改這類(lèi)變量名。
此外，你也可以在模塊頂層把變量名的字符串列表賦值給變量名 __all__ ，以達到類(lèi)似于 _x 命名慣例的隱藏效果。
使用此功能時(shí)，from * 語(yǔ)句只會(huì )把列在 __all__ 列表中的這些變量名賦值出來(lái)。事實(shí)上這和 x 慣例相反 __all 時(shí)指出要復制的變量名，而_x 是指出不被復制的變量名。Python 會(huì )先尋找模塊內的 __all _ 列表；如果沒(méi)有定義的話(huà)，from * 就會(huì )復制出開(kāi)頭沒(méi)有單下劃線(xiàn)的所有變量名。
就像 _x 慣例一樣，__all__ 列表只對 from * 語(yǔ)句這種形式有效，它并不是私有聲明。
（4）擴展的導入語(yǔ)句（as）
有時(shí)候你導入的模塊名或是模塊屬性名稱(chēng)已經(jīng)在你的程序中使用了，或者你不想使用導入的名字，可能是它太長(cháng)不便輸入什么的。 這已經(jīng)成為 Python 程序員的一個(gè)普遍需求：使用自己想要的名字替換模塊的原始名稱(chēng)。使用擴展的 as 子句，你就可以在導入的同時(shí)指定局部綁定名稱(chēng)。
import 語(yǔ)句和 from 語(yǔ)句都可以擴展，讓模塊可以在腳本中給予不同的變量名。
import modulename as name相當于：import modulenamename = modulenamedel modulenamefrom modulename import attrname as name相當于：from modulename import attrnamename = attrnamedel attrname
這個(gè)擴展功能很常用，替代變量名較長(cháng)的變量提供簡(jiǎn)短一些的同義詞，而且當已在腳本中使用一個(gè)變量名使得執行普通 import 語(yǔ)句會(huì )被覆蓋時(shí)，使用 as，就可避免變量名沖突。
4、模塊重載
在同一個(gè)進(jìn)程中模塊只在第一次導入時(shí)，加載和執行該模塊的代碼。之后的導入只會(huì )使用已加載的模塊對象，而不會(huì )重載或重新執行文件的代碼。要強制使模塊重新載入并重新運行，可以使用 reload() 函數。
reload()
reload() 函數位于Python中的 imp 模塊內，使用前必須先導入。它會(huì )強制已加載的模塊的代碼重新載入并重新執行。因為 reload() 期望得到的是對象，在重載之前，模塊一定是已經(jīng)預先成功導入了。
重新執行模塊文件的代碼會(huì )覆蓋其現有的命名空間。重載會(huì )影響所有使用 import 導入模塊的程序，因為使用 import 的程序需要通過(guò)點(diǎn)號運算符取出屬性，在重載后，使用的模塊對象變成了新的值。重載只會(huì )對重載后使用 from 語(yǔ)句導入模塊的程序造成影響。之前使用 from 來(lái)讀取屬性的客戶(hù)端并不會(huì )受到重載的影響，那些程序引用的依然是重載前所取出的舊對象。
reload() 函數使得可以修改模塊程序的一些代碼，而無(wú)須停止整個(gè)程序。因此，利用reload() ，可以立即看到對模塊的修改效果。重載無(wú)法用于每種情況，但是能用時(shí)，可縮短開(kāi)發(fā)的流程。一般的用法是：導入一個(gè)模塊，在文本編輯器內修改其源代碼，然后將其重載。當調用 reload() 時(shí)，Python 會(huì )重讀模塊文件的源代碼，重新執行其頂層語(yǔ)句。
因為 Python 是解釋性的（或多或少），其實(shí)已經(jīng)避免了類(lèi)似 C 語(yǔ)言程序執行時(shí)所需的編譯連接步驟：在執行程序導入時(shí)，模塊會(huì )動(dòng)態(tài)加載。重載進(jìn)一步的提供了性能優(yōu)勢，讓你可以修改執行中的程序的一部分，而不需要中止。注意：reload() 當前只能用在Python 編寫(xiě)的模塊；用 C 這類(lèi)語(yǔ)言編寫(xiě)的編譯后的擴展模塊也可在執行中動(dòng)態(tài)加載，但無(wú)法重載。
