1、什麼是模塊 如果從Python解釋器退出並再次輸入，您所做的定義（函數和變數）將丟失。因此，如果要編寫一個稍長的程式，最好使用文本編輯器為解釋器準備輸入，並以該文件作為輸入運行它。這稱為創建腳本。隨著你的程式越來越長，你可能想把它分成幾個文件，以方便維護。你可能還想使用一個你在幾個程式中編寫的方 ...
1、什麼是模塊
如果從Python解釋器退出並再次輸入，您所做的定義（函數和變數）將丟失。因此，如果要編寫一個稍長的程式，最好使用文本編輯器為解釋器準備輸入，並以該文件作為輸入運行它。這稱為創建腳本。隨著你的程式越來越長，你可能想把它分成幾個文件，以方便維護。你可能還想使用一個你在幾個程式中編寫的方便的函數，而不必將它的定義複製到每個程式中。
為了支持這一點，Python有一種方法將定義放在一個文件中，併在腳本中或在解釋器的交互實例中使用它們。這樣的文件稱為模塊；模塊中的定義可以導入到其他模塊或主模塊（您可以在頂層和計算器中執行的腳本中訪問的變數的容器模式）。
- 模塊是一個包含Python定義和語句的文件
- 文件名就是模塊名以 擴展名.py 結尾
- 在模塊內部，模塊名 (一個字元串) 可以通過一個全局變數 __name__取得
2、使用內置模塊與自定義模塊
Python本身就內置了很多非常有用的模塊，只要安裝完畢，這些模塊就可以立刻使用。
我們以內建的sys模塊為例，編寫一個hello的模塊：
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """a test module """ __author__ = 'roy' import sys def test(): args = sys.argv if len(args) == 1: print('Hello, world!') elif len(args) == 2: print('Hello, %s!' % args[1]) else: print('Too many arguments!') if __name__ == '__main__': test()
以上就是Python模塊的標準文件模板，當然也可以全部刪掉不寫，但是，按標準辦事肯定沒錯。
第1行和第2行是標準註釋，第1行註釋可以讓這個hello.py文件直接在Unix/Linux/Mac上運行，第2行註釋表示.py文件本身使用標準UTF-8編碼；
第4行是一個字元串，表示模塊的文檔註釋，任何模塊代碼的第一個字元串都被視為模塊的文檔註釋；
第6行使用__author__變數把作者寫進去，這樣當你公開源代碼後別人就可以瞻仰你的大名；
import 語句
想使用 Python 源文件，只需在另一個源文件里執行 import 語句，語法如下：
import module1[, module2[,... moduleN]
當解釋器遇到 import 語句，如果模塊在當前的搜索路徑就會被導入。搜索路徑是一個解釋器會先進行搜索的所有目錄的列表。如想要導入模塊，需要把命令放在腳本的頂端。
一個模塊只會被導入一次，不管你執行了多少次import。這樣可以防止導入模塊被一遍又一遍地執行。
當我們使用import語句的時候，Python解釋器是怎樣找到對應的文件的呢？這就涉及到Python的搜索路徑，搜索路徑是由一系列目錄名組成的，Python解釋器就依次從這些目錄中去尋找所引入的模塊。
這看起來很像環境變數，事實上，也可以通過定義環境變數的方式來確定搜索路徑。
搜索路徑是在Python編譯或安裝的時候確定的，安裝新的庫應該也會修改。搜索路徑被存儲在sys模塊中的path變數，做一個簡單的實驗，在互動式解釋器中，輸入以下代碼：
>>> import sys >>> sys.path ['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages'] >>>
sys.path 輸出是一個列表，其中第一項是空串''，代表當前目錄（若是從一個腳本中列印出來的話，可以更清楚地看出是哪個目錄），亦即我們執行python解釋器的目錄（對於腳本的話就是運行的腳本所在的目錄）。
現在，在解釋器的當前目錄或者 sys.path 中的一個目錄裡面來創建一個fibo.py的文件，代碼如下：
# 斐波那契(fibonacci)數列模塊 def fib(n): # 定義到 n 的斐波那契數列 a, b = 0, 1 while b < n: print(b, end=' ') a, b = b, a + b print() def fib2(n): # 返回到 n 的斐波那契數列 result = [] a, b = 0, 1 while b < n: result.append(b) a, b = b, a + b return result
然後進入Python解釋器，使用下麵的命令導入這個模塊：
>>> import fibo
這樣做並沒有把直接定義在fibo中的函數名稱寫入到當前符號表裡，只是把模塊fibo的名字寫到了那裡。
可以使用模塊名稱來訪問函數：
>>> fibo.fib(1000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ 'fibo'
如果你打算經常使用一個函數，你可以把它賦給一個本地的名稱：
>>> fib = fibo.fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
from…import 語句
Python的from語句讓你從模塊中導入一個指定的部分到當前命名空間中，語法如下：
from modname import name1[, name2[, ... nameN]]
例如，要導入模塊 fibo 的 fib 函數，使用如下語句：
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
這個聲明不會把整個fibo模塊導入到當前的命名空間中，它只會將fibo里的fib函數引入進來。
From…import* 語句
把一個模塊的所有內容全都導入到當前的命名空間也是可行的，只需使用如下聲明：
from modname import *
這提供了一個簡單的方法來導入一個模塊中的所有項目。然而這種聲明不該被過多地使用。
深入模塊
模塊除了方法定義，還可以包括可執行的代碼。這些代碼一般用來初始化這個模塊。這些代碼只有在第一次被導入時才會被執行。
每個模塊有各自獨立的符號表，在模塊內部為所有的函數當作全局符號表來使用。所以，模塊的作者可以放心大膽的在模塊內部使用這些全局變數，而不用擔心把其他用戶的全局變數搞花。
從另一個方面，當你確實知道你在做什麼的話，你也可以通過 modname.itemname 這樣的表示法來訪問模塊內的函數。
模塊是可以導入其他模塊的。在一個模塊（或者腳本，或者其他地方）的最前面使用 import 來導入一個模塊，當然這隻是一個慣例，而不是強制的。被導入的模塊的名稱將被放入當前操作的模塊的符號表中。還有一種導入的方法，可以使用 import 直接把模塊內（函數，變數的）名稱導入到當前操作模塊。比如:
>>> from fibo import fib, fib2 >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
這種導入的方法不會把被導入的模塊的名稱放在當前的字元表中（所以在這個例子裡面，fibo 這個名稱是沒有定義的）。這還有一種方法，可以一次性的把模塊中的所有（函數，變數）名稱都導入到當前模塊的字元表：
>>> from fibo import * >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
這將把所有的名字都導入進來，但是那些由單一下劃線（_）開頭的名字不在此例。大多數情況， Python程式員不使用這種方法，因為引入的其它來源的命名，很可能覆蓋了已有的定義。
作用域
在一個模塊中，我們可能會定義很多函數和變數，但有的函數和變數我們希望給別人使用，有的函數和變數我們希望僅僅在模塊內部使用。在Python中，是通過 _ 首碼來實現的。
正常的函數和變數名是公開的（public），可以被直接引用，比如：abc，PI等；類似 __xxx__ 這樣的變數是特殊變數，可以被直接引用，但是有特殊用途，比如上面的 __author__ 就是特殊變數，hello模塊定義的文檔註釋也可以用特殊變數 __doc__ 訪問，我們自己的變數一般不要用這種變數名；類似 _xxx 和 __xxx 這樣的函數或變數就是非公開的（private），不應該被直接引用；
之所以我們說，private函數和變數“不應該”被直接引用，而不是“不能”被直接引用，是因為Python並沒有一種方法可以完全限制訪問private函數或變數，但是，從編程習慣上不應該引用private函數或變數。
__name__屬性
一個模塊被另一個程式第一次引入時，其主程式將運行。如果我們想在模塊被引入時，模塊中的某一程式塊不執行，我們可以用__name__屬性來使該程式塊僅在該模塊自身運行時執行。
#!/usr/bin/python3 # Filename: using_name.py if __name__ == '__main__': print('程式自身在運行') else: print('我來自另一模塊')
說明： 每個模塊都有一個__name__屬性，當其值是'__main__'時，表明該模塊自身在運行，否則是被引入。
dir() 函數
內置的函數 dir() 可以找到模塊內定義的所有名稱。以一個字元串列表的形式返回：
>>> import fibo, sys >>> dir(fibo) ['__name__', 'fib', 'fib2'] >>> dir(sys) ['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__', '__package__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe', '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags', 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount', 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions']
如果沒有給定參數，那麼 dir() 函數會羅列出當前定義的所有名稱：
>>> a = [1, 2, 3, 4, 5] >>> import fibo >>> fib = fibo.fib >>> dir() # 得到一個當前模塊中定義的屬性列表 ['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys'] >>> a = 5 # 建立一個新的變數 'a' >>> dir() ['__builtins__', '__doc__', '__name__', 'a', 'sys'] >>> >>> del a # 刪除變數名a >>> >>> dir() ['__builtins__', '__doc__', '__name__', 'sys'] >>>
包（Package）
你也許還想到，如果不同的人編寫的模塊名相同怎麼辦？為了避免模塊名衝突，Python又引入了按目錄來組織模塊的方法，稱為包（Package）。
不妨假設你想設計一套統一處理聲音文件和數據的模塊（或者稱之為一個"包"）。
現存很多種不同的音頻文件格式（基本上都是通過尾碼名區分的，例如： .wav，:file:.aiff，:file:.au，），所以你需要有一組不斷增加的模塊，用來在不同的格式之間轉換。
並且針對這些音頻數據，還有很多不同的操作（比如混音，添加回聲，增加均衡器功能，創建人造立體聲效果），所以你還需要一組怎麼也寫不完的模塊來處理這些操作。
這裡給出了一種可能的包結構（在分層的文件系統中）：
sound/ 頂層包 __init__.py 初始化 sound 包 formats/ 文件格式轉換子包 __init__.py wavread.py wavwrite.py aiffread.py aiffwrite.py auread.py auwrite.py ... effects/ 聲音效果子包 __init__.py echo.py surround.py reverse.py ... filters/ filters 子包 __init__.py equalizer.py vocoder.py karaoke.py ...
- 包是一種管理 Python 模塊命名空間的形式，採用"點模塊名稱"。比如一個模塊的名稱是 A.B， 那麼他表示一個包 A中的子模塊 B 。就好像使用模塊的時候，你不用擔心不同模塊之間的全局變數相互影響一樣，採用點模塊名稱這種形式也不用擔心不同庫之間的模塊重名的情況。
- 在導入一個包的時候，Python 會根據 sys.path 中的目錄來尋找這個包中包含的子目錄。
- 目錄只有包含一個叫做 __init__.py 的文件才會被認作是一個包，主要是為了避免一些濫俗的名字（比如叫做 string）不小心的影響搜索路徑中的有效模塊。
- 最簡單的情況，放一個空的file:__init__.py就可以了。當然這個文件中也可以包含一些初始化代碼或者為（將在後面介紹的） __all__變數賦值。
- __init__.py 本身就是一個模塊，而它的模塊名就是包文件夾的名稱，如 sound。
用戶可以每次只導入一個包裡面的特定模塊，比如：
import sound.effects.echo
這將會導入子模塊:sound.effects.echo。 他必須使用全名去訪問：
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
還有一種導入子模塊的方法是：
from sound.effects import echo
這同樣會導入子模塊: echo，並且他不需要那些冗長的首碼，所以他可以這樣使用：
echo.echofilter(input, output, delay=0.7, atten=4)
還有一種變化就是直接導入一個函數或者變數：
from sound.effects.echo import echofilter
同樣的，這種方法會導入子模塊: echo，並且可以直接使用他的 echofilter() 函數：
echofilter(input, output, delay=0.7, atten=4)
註意：當使用from package import item這種形式的時候，對應的item既可以是包裡面的子模塊（子包），或者包裡面定義的其他名稱，比如函數，類或者變數。import語法會首先把item當作一個包定義的名稱，如果沒找到，再試圖按照一個模塊去導入。如果還沒找到，恭喜，一個:exc:ImportError 異常被拋出了。反之，如果使用形如import item.subitem.subsubitem這種導入形式，除了最後一項，都必須是包，而最後一項則可以是模塊或者是包，但是不可以是類，函數或者變數的名字。
從一個包中導入*
設想一下，如果我們使用 from sound.effects import *會發生什麼？
Python 會進入文件系統，找到這個包裡面所有的子模塊，一個一個的把它們都導入進來。
但是很不幸，這個方法在 Windows平臺上工作的就不是非常好，因為Windows是一個大小寫不區分的系統。
在這類平臺上，沒有人敢擔保一個叫做 ECHO.py 的文件導入為模塊 echo 還是 Echo 甚至 ECHO。
（例如，Windows 95就很討厭的把每一個文件的首字母大寫顯示）而且 DOS 的 8+3 命名規則對長模塊名稱的處理會把問題搞得更糾結。
為瞭解決這個問題，只能煩勞包作者提供一個精確的包的索引了。
導入語句遵循如下規則：如果包定義文件 __init__.py 存在一個叫做 __all__ 的列表變數，那麼在使用 from package import * 的時候就把這個列表中的所有名字作為包內容導入。
作為包的作者，可別忘了在更新包之後保證 __all__ 也更新了啊。你說我就不這麼做，我就不使用導入* 這種用法，好吧，沒問題，誰讓你是老闆呢。這裡有一個例子，在：file:sounds/effects/__init__.py中包含如下代碼：
__all__ = ["echo", "surround", "reverse"]
這表示當你使用from sound.effects import *這種用法時，你只會導入包裡面這三個子模塊。
如果 __all__ 真的沒有定義，那麼使用from sound.effects import *這種語法的時候，就不會導入包 sound.effects 里的任何子模塊。他只是把包sound.effects和它裡面定義的所有內容導入進來（可能運行__init__.py里定義的初始化代碼）。這會把 __init__.py 裡面定義的所有名字導入進來。並且他不會破壞掉我們在這句話之前導入的所有明確指定的模塊。看下這部分代碼：
import sound.effects.echo import sound.effects.surround from sound.effects import *
這個例子中，在執行from...import前，包sound.effects中的echo和surround模塊都被導入到當前的命名空間中了。（當然如果定義了__all__就更沒問題了）
通常我們並不主張使用*這種方法來導入模塊，因為這種方法經常會導致代碼的可讀性降低。不過這樣倒的確是可以省去不少敲鍵的功夫，而且一些模塊都設計成了只能通過特定的方法導入。
記住，使用from Package import specific_submodule這種方法永遠不會有錯。事實上，這也是推薦的方法。除非是你要導入的子模塊有可能和其他包的子模塊重名。
如果在結構中包是一個子包（比如這個例子中對於包sound來說），而你又想導入兄弟包（同級別的包）你就得使用導入絕對的路徑來導入。比如，如果模塊sound.filters.vocoder 要使用包sound.effects中的模塊echo，你就要寫成 from sound.effects import echo。
from . import echo from .. import formats from ..filters import equalizer
無論是隱式的還是顯式的相對導入都是從當前模塊開始的。主模塊的名字永遠是"__main__"，一個Python應用程式的主模塊，應當總是使用絕對路徑引用。
包還提供一個額外的屬性__path__。這是一個目錄列表，裡面每一個包含的目錄都有為這個包服務的__init__.py，你得在其他__init__.py被執行前定義哦。可以修改這個變數，用來影響包含在包裡面的模塊和子包。這個功能並不常用，一般用來擴展包裡面的模塊。
3、使用第三方模塊
在Python中，安裝第三方模塊，是通過包管理工具pip完成的。
如果你正在使用Mac或Linux，安裝pip本身這個步驟就可以跳過了。如果你正在使用Windows，請確保全裝Python時勾選了pip和Add python.exe to Path。
在命令提示符視窗下嘗試運行pip，如果Windows提示未找到命令，可以重新運行安裝程式添加pip。
註意：Mac或Linux上有可能並存Python 3.x和Python 2.x，因此對應的pip命令是pip3。
一般來說，第三方庫都會在Python官方的pypi.python.org網站註冊，要安裝一個第三方庫，必須先知道該庫的名稱，可以在官網或者pypi上搜索，比如Pillow的名稱叫Pillow，因此，安裝Pillow的命令就是：
pip install Pillow
耐心等待下載並安裝後，就可以使用Pillow了。
在使用Python時，我們經常需要用到很多第三方庫，例如，上面提到的Pillow，以及MySQL驅動程式，Web框架Flask，科學計算Numpy等。用pip一個一個安裝費時費力，還需要考慮相容性。所以很多開發人員喜歡使用Anaconda，這是一個基於Python的數據處理和科學計算平臺，它已經內置了許多非常有用的第三方庫，我們裝上Anaconda，就相當於把數十個第三方模塊自動安裝好了，非常簡單易用。
可以從Anaconda官網下載GUI安裝包，安裝包有500~600M，所以需要耐心等待下載。下載後直接安裝，Anaconda會把系統Path中的python指向自己自帶的Python，並且，Anaconda安裝的第三方模塊會安裝在Anaconda自己的路徑下，不影響系統已安裝的Python目錄。
