Python : Module

          在Python中，一個.py文件表明一個Module。在Module中能夠是任何的符合Python文件格式的Python腳本。瞭解Module導入機制大有用處。

• 1 Module 組成
  • 1.1 Module 內置全局變量
  • 1.2 dir() 的妙用
• 2 Module 導入
  • 2.1 導入及其使用
  • 2.2 一次加載屢次導入
  • 2.3 搜索路徑
  • 2.4 reload
• 3 Package
  • 3.1 __init__.py
  • 3.2 __all__
  • 3.3 __path__

 

1 Module組成

         一個.py文件就是一個module。Module中包括attribute, function等。 這裏說的attribute實際上是module的global variable。

在一個ModuleTests.py文件中：

#!python
#-*- coding: utf-8 -*-

"""
全局變量
"""

# hello doc
global moduleName
moduleName = __name__
a = 1

def printModuleName():
    print(a+1)
    print(__name__)
    print(moduleName)

'''
if __name__ == '__main__' : 
    print('current module name is "' + __name__+'"')
'''


printModuleName()
print(a)
print(dir())

import __builtin__
print(__builtin__ == __builtins__)
print(__doc__)
print(__file__)
print(__name__)
print(__package__)
__name__ = 'hello'
print(__name__)

View Code

         除了你本身定義的那些全局變量和函數外，每個module還有一些內置的全局變量。在這個module就包括了三個attribute：a,moduleName,printModuleName。若是該模塊被導入到另外一個模塊，在另個一模塊中，就能夠經過某種方式來訪問這三個attribute。

 

1.1 Module 內置全局變量

         每個模塊，都會有一些默認的attribute（全局變量）。dir()函數 是python中的一個頂級函數，敢於查看模塊內容。例如上面的例子中，使用dir()查看結果是：

 ['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'a', 'moduleName', 'printModuleName']。其中a, moduleName, printModuleName 是由用戶自定義的。其餘的全是內置的。

        1）__name__ ：模塊的名稱。例如上面的ModuleTests.py，模塊的名稱默認就是ModuleTests。在運行時，若是一個module是程序入口，那麼__name__就是」__main__」。它是最經常使用的。

        2）__builtins__：在Python中有一個內置的module，叫作：__builtin__，它是一個Python的模塊。而任何一個Python的模塊都有一個__builtins__全局變量，它就是內置模塊__builtin__的引用。能夠經過以下代碼測試：

import __builtin__
print(__builtin__ == __builtins__)

        // 測試結果是True

在Python代碼裏，不須要咱們導入就能直接使用的函數，類等，都是在這個內置模塊裏的。例如：range(),bytes(),dir()。

        3）__doc__：module的文檔說明。即使是Python的初學者都知道Python中的多行註釋是用三對單引號或者雙引號包含的。網上有人說__doc__其實就是註釋，這句話呢說的太隨意容易給人誤解。通過測試，模塊的__doc__應該是：文件頭以後、代碼（包含import）以前 的 第一個 多行註釋。 方法的__doc__是方法前的那個註釋。

在交換模式下，咱們能夠直接使用__doc__來查看方法的說明的。例如查看string.split方法的說明：str.split.__doc__就能夠了。

 

        4）__file__：當前module所在的文件的路徑。

        5）__package__：當前module所在的包名。若是沒有，爲None。

 

1.2 dir()的妙用 

        dir()是一個內置函數，用於查找指定的module中包括哪些attribute和method （或者function）。若是不指定參數，默認是當前module。上面說了range,dir,bytes等都是在內置模塊裏的，那麼究竟是不是呢？

        dir(__builtins__)就可看到了：

 

 

2 Module導入

2.1 導入及其使用

         一個Module能夠導入（import）到其餘的Python腳本中使用。導入方式有多種：

        1）import module1

        2）import module1 as m1

        3）from module1 import xxx

        4）from module1 import xxx as yyy

        從包（package）導入，也分爲相似的三種：

        1）import p1.p2.p3.module1 

        2）import p1.p2.p3.module1 as m1

        3）from p1.p2.p3.module1 import xxx

        4）from p1.p2.p3.module1 import xxx as yyy

        假設module1有兩個attribue: a1,a2， 兩個function: f1,f2下面來講明這幾種導入方式的區別：

         方式一是導入整個module1, 並將賦值給一個變量module1，來供使用。使用時，可使用module1.a1, module1.a2, module1.f1(params), module.f2(params)

         方式二是在方式一的基礎上，重命名爲m1,也就是說使用時得使用： m1.a1, m1.a2, m1.f1, m1.f2。

         方式三是導入模塊的部份內容（導入一個或者一些attribute或者function） 。例如 from module1 import a1，導入完成後，在當前的模塊中建立了一個 a1的變量。調用是直接調用a1便可。

         方式四對於導入一個attribute或者function時，能夠重命名。例如 from module1 import a1 as msg，那麼導入完畢，就是在當前的模塊中建立了一個msg的變量，指向了module1.a1。 咱們在調用時，只能經過msg來調用。

  

2.2 一次加載屢次導入

 

       對於上面的4種導入方式，不論哪種，都有兩個階段：1）找到module對象，2）按需分配給變量。

       模塊自己就是爲了複用的。在一個大的項目中，一些基礎的、公共的模塊一般會被大量使用，也就是說會被不少的module導入使用。咱們也知道，module是放在py文件中的。如個一個module被大量導入時，難道要每一次導入，都去磁盤上找一py文件嗎？

       顯然不能這樣設計，若是真的這樣設計，程序的性能將是極差的了。

       對於一樣的問題，Java中的作法是，使用ClassLoader加載類，並採用父加載器委託機制。儘量的保證，同一個ClassLoader下，在屢次引用一個類時，都是同一個。咱們能夠將該方式稱爲一次加載，多地使用。

       Python的設計者，也考慮到這個問題。也採用了相似方案，被我稱爲一次加載，屢次導入。咱們假設它有一個Module Loader的存在，在首次加載（實際上是首次import）時，執行流程以下：

       1）由Module Loader從檢索路徑下找出相應的模塊

       2）編譯或者找到合適的字節碼文件（.pyc結尾）

       3）解釋執行要導入的Module，並放入緩存。

       4）將導入的Module對象（或者其屬性）分配給當前Module下的變量。

      隨後整個程序中再有執行import該moudle時，只須要從緩存中拿到該module，而後執行4）。

 

       此外，對於過程2）有這樣4種狀況：

       A: 若.py與.pyc都存在：會對.py文件的最後修改時間與.pyc文件的最後修改時間比較。執行時間靠後的那個。

       B: 若.py與.pyc都不存在，繼續找，若是最終都沒有找到，出錯。

       C: 若.py存在，.pyc不存在：編譯.py爲.pyc。

       D:若.py不存在，.pyc存在，直接執行.pyc。

 

       再者還要說明2點：

       1）一次加載，屢次導入的機制，在Python程序包中提供的交互式命令行裏使用import是無論用的。在交互式下，一次加載只能用於一次導入。

       2）通常main py是不會被編譯成pyc的，一個模塊要想被編譯成pyc，須要import到其餘模塊才行。

 

2.3 搜索路徑

       依據Java編程經驗來看，一般程序會將文件放在不一樣的地方。Python必然也不例外。Python的搜索順序爲：

       1）  已加載模塊的緩存

       2）  內置模塊

       3）  sys.path

       其中sys.path包含如下幾部分：

       1）入口程序的目錄

       2）系統環境變量PYTHONPATH表明的目錄

       3）標準Python庫目錄

       4）任何.pth文件的內容（若是存在的話）

      

       下面使用命令看一下sys.path的目錄有哪些：

['',
'C:\\windows\\SYSTEM32\\python27.zip',
'D:\\Program Files\\Python\\Python27\\DLLs',
'D:\\Program Files\\Python\\Python27\\lib',
'D:\\Program Files\\Python\\Python27\\lib\\plat-win',
'D:\\Program Files\\Python\\Python27\\lib\\lib-tk',
'D:\\Program Files\\Python\\Python27',
'D:\\Program Files\\Python\\Python27\\lib\\site-packages']

        若是要加載的module不在上述目錄下，能夠經過3鍾手段：

        1）  配置環境變量PYTHONPATH，配置是與環境變量PATH的風格同樣。

        2）  程序動態修改sys.path

        3）  放到site-packages目錄下。

 

2.4 reload()

        有些狀況下，咱們須要在程序運行是對程序代碼作修改。例如咱們須要監控某一方法執行快慢，是否存在性能問題時。咱們須要在function的開始、結束部分記錄一個startTime,endTime，依此來斷定執行性能時。像這樣的場景下，由於Module的加載一次，多長調用的機制，咱們修改完代碼，也不會生效。此時就須要一種機制來從新加載module，以達到指望效果。reload() 就能夠解決這個問題。

        reload(module) 是一個函數，參數是一個module對象。執行reload，就會等於再一次進行加載。

 

3 Package

 

3.1 __init__.py

        每個package下必須有一個__init__.py文件，該文件用於代表當前目錄能夠做爲一個package。

        __init__.py 也是一個python，當首次加載相應的package時，會執行__init__.py。

        __init__.py文件能夠什麼也沒有，也能夠指定__all__或（和）__path。

 

3.2 __all__

       __all__的值是一個列表，用於當程序中使用 from pkg1.pkg2.pkg3 import * 時。

       就拿Python_HOME/Lib/下的json包來作實驗，因爲該文件比較大，我就寫出主要部分：

__version__ = '2.0.9'
__all__ = [
    'dump', 'dumps', 'load', 'loads',
    'JSONDecoder', 'JSONEncoder',
]
__author__ = 'Bob Ippolito <bob@redivi.com>'

from .decoder import JSONDecoder
from .encoder import JSONEncoder

def dump(params):
    pass

def dumps(params):
    pass

def load(params):
    pass

def loads(params):
    pass

       目錄結構以下： 

 

       當程序中使用 from json import * 引發json包首次加載時，執行過程以下：

       1）找到json目錄，執行__init__.py 執行完畢後：包下會暴漏出：load,loads,dump.dumps, JSONDecoder, JSONEncoder

       2）查找* ，即從__all__找出要導出的變量。

 

       當程序使用Import json.encoder引發json包首次加載時，執行過程以下：

       1）找到json目錄，執行__init__.py 執行完畢後：包下會暴漏出：load,loads,dump.dumps, JSONDecoder, JSONEncoder （以供from json import * 使用）

       2）導入json包到一個變量裏（此後程序能夠直接使用json.encoder, json.decoder,json.scanner）

 

       上述結論，來源於下面的測試用例：

#!python
#-*- coding: utf-8 -*-

"""
Package Import Test
"""

#from json import *
from json import encoder
import json

print(json.encoder == encoder)
print(json.decoder is None)
print(json.scanner is None)
print(dir())

 

3.3 __path__ 

       該變量用於配置包下的搜索位置。例如：

       在Utils下增長2個目錄Linux和Windows, 並各有一個echo.py文件, 目錄以下 

 Sound/Utils/  
    |-- Linux        目錄下沒有__init__.py文件, 不是包, 只是一個普通目錄  
    |   `-- echo.py  
    |-- Windows      目錄下沒有__init__.py文件, 不是包, 只是一個普通目錄  
    |   `-- echo.py  
    |-- __init__.py  
    |-- echo.py  
    |-- reverse.py  
    `-- surround.py  

      若是__init__.py是空的，當使用import Sound.Utils.echo導入echo時，會導入的是Sound/Utils/echo.py。   

      接下來我將__init__.py作以下修改：

import sys 
import os 

print "Sound.Utils.__init__.__path__ before change:", __path__ 

dirname = __path__[0] 
if sys.platform[0:5] == 'linux': 
        __path__.insert( 0, os.path.join(dirname, 'Linux') ) 
else: 
        __path__.insert( 0, os.path.join(dirname, 'Windows') ) 
print "Sound.Utils.__init__.__path__ AFTER change:", __path__

      在Linux上執行import Sound.Utils.echo，那麼搜索路徑就會變成了： 'Sound/Utils/Linux', 'Sound/Utils'。以此來達到自動化的按需加載響應的module的功能。