# Python 模塊
在前面的幾個章節中我們腳本上是用python解釋器來編程,如果你從Python解釋器退出再進入,那么你定義的所有的方法和變量就都消失了。
為此 Python 提供了一個辦法,把這些定義存放在文件中,為一些腳本或者交互式的解釋器實例使用,這個文件被稱為模塊。
模塊是一個包含所有你定義的函數和變量的文件,其后綴名是.py。模塊可以被別的程序引入,以使用該模塊中的函數等功能。這也是使用python標準庫的方法。下面是一個使用python標準庫中模塊的例子。
```
#!/usr/bin/python3
# Filename: using_sys.py
import sys
print('命令行參數如下:')
for i in sys.argv:
print(i)
print('/n/nThe PYTHONPATH is', sys.path, '/n')
```
執行結果如下所示:
```
E:\python33\src>python using_sys.py 參數1 參數2
命令行參數如下:
using_sys.py
參數1
參數2
/n/nThe PYTHONPATH is ['E:\\python33\\src', 'C:\\Windows\\system32\\python33.zip
', 'E:\\python33\\DLLs', 'E:\\python33\\lib', 'E:\\python33', 'E:\\python33\\lib
\\site-packages'] /n
```
* 1、import sys引入python標準庫中的sys.py模塊;這是引入某一模塊的方法。
* 2、sys.argv是一個包含命令行參數的列表。
* 3、sys.path包含了一個Python解釋器自動查找所需模塊的路徑的列表。
當我們使用import語句的時候,Python解釋器是怎樣找到對應的文件的呢?
這就涉及到Python的搜索路徑,搜索路徑是由一系列目錄名組成的,Python解釋器就依次從這些目錄中去尋找鎖引入的模塊。
這看起來很像環境變量,事實上,也可以通過定義環境變量的方式來確定搜索路徑。
搜索路徑是在Python編譯或安裝的時候確定的,安裝新的庫應該也會修改。搜索路徑被存儲在sys模塊中的path變量,做一個簡單的實驗,在交互式解釋器中,輸入以下代碼:
```
import sys
sys.path
```
輸出結果:
```
>>> sys.path
['', 'E:\\python33\\Lib\\idlelib', 'C:\\Windows\\system32\\python33.zip', 'E:\\python33\\DLLs', 'E:\\python33\\lib', 'E:\\python33', 'E:\\python33\\lib\\site-packages']
```
sys.path輸出是一個列表,其中第一項是空串'',代表當前目錄(若是從一個腳本中打印出來的話,可以更清楚地看出是哪個目錄),亦即我們執行python解釋器的目錄(對于腳本的話就是運行的腳本所在的目錄)。
因此若像我一樣在當前目錄下存在與要引入模塊同名的文件,就會把要引入的模塊屏蔽掉。
了解了搜索路徑的概念,就可以在腳本中修改sys.path來引入一些不在搜索路徑中的模塊。
現在,在解釋器的當前目錄或者sys.path中的一個目錄里面來創建一個fibo.py的文件,代碼如下:
```
# Fibonacci numbers module
def fib(n): # write Fibonacci series up to n
a, b = 0, 1
while b < n:
print(b, end=' ')
a, b = b, a+b
print()
def fib2(n): # return Fibonacci series up to 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
```
## 深入模塊
模塊除了方法定義,還可以包括可執行的代碼。這些代碼一般用來初始化這個模塊。這些代碼只有在第一次被導入時才會被執行。
每個模塊有各自獨立的符號表,在模塊內部為所有的函數當作全局符號表來使用。
所以,模塊的作者可以放心大膽的在模塊內部使用這些全局變量,而不用擔心把其他用戶的全局變量搞花。
從另一個方面,當你確實知道你在做什么的話,你也可以通過 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程序員不使用這種方法,因為引入的其它來源的命名,很可能覆蓋了已有的定義。
## __name__屬性
一個模塊被另一個程序第一次引入時,其主程序將運行。如果我們想在模塊被引入時,模塊中的某一程序塊不執行,我們可以用__name__屬性來使該程序塊僅在該模塊自身運行時執行。
```
#!/usr/bin/python3
# Filename: using_name.py
if __name__ == '__main__':
print('程序自身在運行')
else:
print('我來自另一模塊')
```
運行輸出如下:
```
$ python using_name.py
```
程序自身在運行
```
$ python
>>> import using_name
我來自另一模塊
>>>
```
**說明:** 每個模塊都有一個__name__屬性,當其值是'__main__'時,表明該模塊自身在運行,否則是被引入。
## dir() 函數
```
內置的函數 dir() 可以找到模塊內定義的所有名稱。以一個字符串列表的形式返回:
</p>
<pre>
>>> 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']
>>>
```
## 標準模塊
Python 本身帶著一些標準的模塊庫,在 Python 庫參考文檔中將會介紹到(就是后面的"庫參考文檔")。
有些模塊直接被構建在解析器里,這些雖然不是一些語言內置的功能,但是他卻能很高效的使用,甚至是系統級調用也沒問題。
這些組件會根據不同的操作系統進行不同形式的配置,比如 winreg 這個模塊就只會提供給 Windows 系統。
應該注意到這有一個特別的模塊 sys ,它內置在每一個 Python 解析器中。變量 sys.ps1 和 sys.ps2 定義了主提示符和副提示符所對應的字符串:
```
>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>
```
## 包
包是一種管理 Python 模塊命名空間的形式,采用"點模塊名稱"。
比如一個模塊的名稱是 A.B, 那么他表示一個包 A中的子模塊 B 。
就好像使用模塊的時候,你不用擔心不同模塊之間的全局變量相互影響一樣,采用點模塊名稱這種形式也不用擔心不同庫之間的模塊重名的情況。
這樣不同的作者都可以提供 NumPy 模塊,或者是 Python 圖形庫。
不妨假設你想設計一套統一處理聲音文件和數據的模塊(或者稱之為一個"包")。
現存很多種不同的音頻文件格式(基本上都是通過后綴名區分的,例如: .wav,:file:.aiff,:file:.au,),所以你需要有一組不斷增加的模塊,用來在不同的格式之間轉換。
并且針對這些音頻數據,還有很多不同的操作(比如混音,添加回聲,增加均衡器功能,創建人造立體聲效果),所你還需要一組怎么也寫不完的模塊來處理這些操作。
這里給出了一種可能的包結構(在分層的文件系統中):
```
sound/ Top-level package
__init__.py Initialize the sound package
formats/ Subpackage for file format conversions
__init__.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py
...
effects/ Subpackage for sound effects
__init__.py
echo.py
surround.py
reverse.py
...
filters/ Subpackage for filters
__init__.py
equalizer.py
vocoder.py
karaoke.py
...
```
在導入一個包的時候,Python 會根據 sys.path 中的目錄來尋找這個包中包含的子目錄。
目錄只有包含一個叫做 __init__.py 的文件才會被認作是一個包,主要是為了避免一些濫俗的名字(比如叫做 string)不小心的影響搜索路徑中的有效模塊。
最簡單的情況,放一個空的 :file:__init__.py就可以了。當然這個文件中也可以包含一些初始化代碼或者為(將在后面介紹的) __all__變量賦值。
用戶可以每次只導入一個包里面的特定模塊,比如:
```
import sound.effects.echo
```
這將會導入子模塊:mod:song.effects.echo。 他必須使用全名去訪問:
```
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
```
還有一種導入子模塊的方法是:
```
from sound.effects import echo
```
這同樣會導入子模塊:mod:echo,并且他不需要那些冗長的前綴,所以他可以這樣使用:
```
echo.echofilter(input, output, delay=0.7, atten=4)
```
還有一種變化就是直接導入一個函數或者變量:
```
from sound.effects.echo import echofilter
```
同樣的,這種方法會導入子模塊:mod:echo,并且可以直接使用他的:func: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 的文件導入為模塊:mod:echo還是:mod:Echo甚至:mod: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 *這種語法的時候,就*不會*導入包:mod:sound.effects里的任何子模塊。他只是把包:mod:sound.effects和它里面定義的所有內容導入進來(可能運行:file:__init__.py里定義的初始化代碼)。
這會把 :file:__init__.py里面定義的所有名字導入進來。并且他不會破壞掉我們在這句話之前導入的所有明確指定的模塊。看下這部分代碼:
```
import sound.effects.echo
import sound.effects.surround
from sound.effects import *
```
這個例子中,在執行from...import前,包:mod:sound.effects中的echo和surround模塊都被導入到當前的命名空間中了。(當然如果定義了__all__就更沒問題了)
通常我們并不主張使用*這種方法來導入模塊,因為這種方法經常會導致代碼的可讀性降低。不過這樣倒的確是可以省去不少敲鍵的功夫,而且一些模塊都設計成了只能通過特定的方法導入。
記住,使用from Package import specific_submodule這種方法永遠不會有錯。事實上,這也是推薦的方法。除非是你要導入的子模塊有可能和其他包的子模塊重名。
如果在結構中包是一個子包(比如這個例子中對于包:mod:sound來說),而你又想導入兄弟包(同級別的包)你就得使用導入絕對的路徑來導入。比如,如果模塊:mod:sound.filters.vocoder 要使用包:mod:sound.effects中的模塊:mod:echo,你就要寫成 from sound.effects import echo。
```
from . import echo
from .. import formats
from ..filters import equalizer
```
無論是隱式的還是顯式的相對導入都是從當前模塊開始的。主模塊的名字永遠是"__main__",一個Python應用程序的主模塊,應當總是使用絕對路徑引用。
包還提供一個額外的屬性,:attr:__path__。這是一個目錄列表,里面每一個包含的目錄都有為這個包服務的:file:__init__.py,你得在其他:file:__init__.py被執行前定義哦。可以修改這個變量,用來影響包含在包里面的模塊和子包。
這個功能并不常用,一般用來擴展包里面的模塊。
- Python 基礎教程
- Python 簡介
- Python 環境搭建
- Python 基礎語法
- Python 變量類型
- Python 運算符
- Python 條件語句
- Python 循環語句
- Python While循環語句
- Python for 循環語句
- Python 循環嵌套
- Python break 語句
- Python continue 語句
- Python pass 語句
- Python 數字
- Python 字符串
- Python 列表(Lists)
- Python 元組
- Python 字典(Dictionary)
- Python 日期和時間
- Python 函數
- Python 模塊
- Python 文件I/O
- Python 異常處理
- Python 高級教程
- Python 面向對象
- Python 正則表達式
- Python CGI編程
- Python 使用SMTP發送郵件
- Python 多線程
- Python 2.x與3??.x版本區別
- Python IDE
- Python JSON
- Python3 教程
- Python3 基礎語法
- Python3 基本數據類型
- Python3 解釋器
- Python3 注釋
- Python3 數字運算
- Python3 字符串
- Python3 列表
- Python3 編程第一步
- Python3 條件控制
- Python3 循環
- Python3 函數
- Python3 數據結構
- Python3 模塊
- Python3 輸入和輸出
- Python3 錯誤和異常
- Python3 類
- Python3 標準庫概覽
- 免責聲明