Python之路--Python基礎5--模塊與包

1、模塊是啥

模塊，用一砣代碼實現了某個功能的代碼集合。 

相似於函數式編程和麪向過程編程，函數式編程則完成一個功能，其餘代碼用來調用便可，提供了代碼的重用性和代碼間的耦合。而對於一個複雜的功能來說，可能須要多個函數才能完成（函數又能夠在不一樣的.py文件中），n個 .py 文件組成的代碼集合就稱爲模塊。

如：os 是系統相關的模塊；file是文件操做相關的模塊

模塊分爲三種：

• 自定義模塊
• 內置模塊
• 開源模塊

 

以spam.py爲例來介紹模塊的使用：文件名spam.py,模塊名spam（下面會用到）

#spam.py
print('from the spam.py') money=1000

def read1(): print('spam模塊：',money) def read2(): print('spam模塊') read1() def change(): global money money=0

 

2、使用模塊之import

一、import的使用

　　模塊能夠包含可執行的語句和函數的定義，這些語句的目的是初始化模塊，它們只在模塊名第一次遇到導入import語句時才執行import語句是能夠在程序中的任意位置使用的,且針對同一個模塊被import屢次,爲了防止你重複導入，python的優化手段是：第一次導入後就將模塊加載到內存了，後續的import語句僅是對已經加載到內存中的模塊對象增長了一次引用，不會從新執行模塊內的語句

#test.py
import spam 
#只在第一次導入時才執行spam.py內代碼,此處的顯式效果是隻打印一次'from the spam.py',固然其餘的頂級代碼也都被執行了,只不過沒有顯示效果.

import spam import spam import spam ''' 執行結果： from the spam.py '''

 ps：咱們能夠從sys.module中找到當前已經加載的模塊，sys.module是一個字典，內部包含模塊名與模塊對象的映射，該字典決定了導入模塊時是否須要從新導入。

 

二、在第一次導入模塊時會作三件事，重複導入會直接引用內存中已經加載好的結果

A.爲源文件(spam模塊)建立新的名稱空間，在spam中定義的函數和方法如果使用到了global時訪問的就是這個名稱空間。

B.在新建立的命名空間中執行模塊中包含的代碼，見初始導入import spam

　　提示:導入模塊時到底執行了什麼？

　　In fact function definitions are also ‘statements’ that are ‘executed’;the execution of a module-level function definition enters the function name in the module’s global symbol table.

　　事實上函數定義也是「被執行」的語句，模塊級別函數定義的執行將函數名放入模塊全局名稱空間表，用globals()能夠查看

C.建立名字spam來引用該命名空間

　　這個名字和變量名沒什麼區別，都是‘第一類的’，且使用spam.名字的方式能夠訪問spam.py文件中定義的名字，spam.名字與test.py中的名字來自兩個徹底不一樣的地方。

 

三、被導入模塊有獨立的名稱空間

　　每一個模塊都是一個獨立的名稱空間，定義在這個模塊中的函數，把這個模塊的名稱空間當作全局名稱空間，這樣咱們在編寫本身的模塊時，就不用擔憂咱們定義在本身模塊中全局變量會在被導入時，與使用者的全局變量衝突

#test.py

import spam money=10
print(spam.money) ''' 執行結果： from the spam.py
1000 ''' 測試一:money與spam.money不衝突

#test.py
import spam def read1(): print('========') spam.read1() ''' 執行結果: from the spam.py spam模塊：1000 ''' 測試二：read1與spam.read1不衝突

#test.py
import spam money=1
 spam.change() print(money) ''' 執行結果： from the spam.py
1 ''' 測試三：執行spam.change()操做的全局變量money仍然是spam中的

 

四、爲模塊名起別名

爲已經導入的模塊起別名的方式對編寫可擴展的代碼頗有用

import spam as sm print(sm.money)  #輸出 1000

舉個栗子：有兩中sql模塊mysql和oracle，根據用戶的輸入，選擇不一樣的sql功能

#mysql.py
def sqlparse(): print('from mysql sqlparse') #oracle.py
def sqlparse(): print('from oracle sqlparse') #test.py
db_type=input('>>: ') if db_type == 'mysql': import mysql as db elif db_type == 'oracle': import oracle as db db.sqlparse()

再舉個栗子：

　　假設有兩個模塊xmlreader.py和csvreader.py，它們都定義了函數read_data(filename):用來從文件中讀取一些數據，但採用不一樣的輸入格式。能夠編寫代碼來選擇性地挑選讀取模塊

if file_format == 'xml': import xmlreader as reader elif file_format == 'csv': import csvreader as reader data=reader.read_date(filename)

 

五、在一行導入多個模塊

1  import sys,os,re

 

3、使用模塊之from...import...

一、from...import...的使用

from spam import read1,read2

 

二、from...import 與import的對比

惟一的區別就是：使用from...import...則是將spam中的名字直接導入到當前的名稱空間中，因此在當前名稱空間中，直接使用名字就能夠了、無需加前綴：spam.

　　from...import...的方式有好處也有壞處

　　好處：使用起來方便了

　　壞處：容易與當前執行文件中的名字衝突

 

 驗證一：當前位置直接使用read1和read2就行了，執行時，仍然以spam.py文件全局名稱空間

#測試一：導入的函數read1，執行時仍然回到spam.py中尋找全局變量money #test.py
from spam import read1 money = 10 read1() ''' 執行結果: from the spam.py spam->read1->money 1000 '''


#測試二:導入的函數read2，執行時須要調用read1(),仍然回到spam.py中找read1() #test.py
from spam import read2 def read1(): print('==========') read2() ''' 執行結果: from the spam.py spam->read2 calling read spam->read1->money 1000 '''

 

驗證二：若是當前有重名read1或者read2，那麼會有覆蓋效果。

#測試三:導入的函數read1，被當前位置定義的read1覆蓋掉了 #test.py
from spam import read1 def read1(): print('==========') read1() ''' 執行結果: ========== '''

 

驗證三：導入的方法在執行時，始終是以源文件爲準的

from spam import money,read1 money=100 #將當前位置的名字money綁定到了100
print(money) #打印當前的名字
read1() #讀取spam.py中的名字money,仍然爲1000

''' from the spam.py 100 spam->read1->money 1000 '''

 

三、也支持as

from spam import read1 as read

 

四、一行導入多個名字

from spam import read1,read2,money

 

五、from...import *

from spam import *   #把spam中全部的不是如下劃線(_)開頭的名字都導入到當前位置

大部分狀況下咱們的python程序不該該使用這種導入方式，由於*你不知道你導入什麼名字，頗有可能會覆蓋掉你以前已經定義的名字。並且可讀性極其的差，在交互式環境中導入時沒有問題。

from spam import * #將模塊spam中全部的名字都導入到當前名稱空間
print(money) print(read1) print(read2) print(change) ''' 執行結果: from the spam.py <function read1 at 0x1012e8158> <function read2 at 0x1012e81e0> <function change at 0x1012e8268> '''

 可使用__all__來控制*（用來發布新版本），在spam.py中新增一行

__all__=['money','read1'] #這樣在另一個文件中用from spam import *就這能導入列表中規定的兩個名字

 

4、模塊的重載（瞭解）

 　　考慮到性能的緣由，每一個模塊只被導入一次,放入字典sys.module中，若是你改變了模塊的內容，你必須重啓程序，python不支持從新加載或卸載以前導入的模塊，

　　有的人類可能會想到直接從sys.module中刪除一個模塊不就能夠卸載了嗎，注意了，你刪了sys.module中的模塊對象仍然可能被其餘程序的組件所引用，於是不會被清除。

　　特別的對於咱們引用了這個模塊中的一個類，用這個類產生了不少對象，於是這些對象都有關於這個模塊的引用。

 

5、py文件區分兩種用途：模塊與腳本

#編寫好的一個python文件能夠有兩種用途：
 一：腳本，一個文件就是整個程序，用來被執行 二：模塊，文件中存放着一堆功能，用來被導入使用 #python爲咱們內置了全局變量__name__，
    當文件被當作腳本執行時：__name__  ==  '__main__' 當文件被當作模塊導入時：__name__  == 模塊名 #做用：用來控制.py文件在不一樣的應用場景下執行不一樣的邏輯
    if __name__ == '__main__':

 

6、模塊搜索路徑

模塊的查找順序是：內存中已經加載的模塊->內置模塊->sys.path路徑中包含的模塊

模塊的查找順序

一、在第一次導入某個模塊時（好比spam），會先檢查該模塊是否已經被加載到內存中（當前執行文件的名稱空間對應的內存），若是有則直接引用

    ps：python解釋器在啓動時會自動加載一些模塊到內存中，可使用sys.modules查看

二、若是沒有，解釋器則會查找同名的內建模塊

三、若是尚未找到就從sys.path給出的目錄列表中依次尋找spam.py文件。

 

須要特別注意的是：咱們自定義的模塊名不該該與系統內置模塊重名。雖然每次都說，可是仍然會有人不停的犯錯。 

 

sys.path從如下位置初始化

　　1 執行文件所在的當前目錄

　　2 PTYHONPATH（包含一系列目錄名，與shell變量PATH語法同樣）

　　3 依賴安裝時默認指定的

注意：在支持軟鏈接的文件系統中，執行腳本所在的目錄是在軟鏈接以後被計算的，換句話說，包含軟鏈接的目錄不會被添加到模塊的搜索路徑中

 

7、包介紹

一、什麼是包

#官網解釋
Packages are a way of structuring Python’s module namespace by using 「dotted module names」 包是一種經過使用‘.模塊名’來組織python模塊名稱空間的方式。 #具體的：包就是一個包含有__init__.py文件的文件夾，因此其實咱們建立包的目的就是爲了用文件夾將文件/模塊組織起來

#須要強調的是：
　　1. 在python3中，即便包下沒有__init__.py文件，import 包仍然不會報錯，而在python2中，包下必定要有該文件，不然import 包報錯 　　2. 建立包的目的不是爲了運行，而是被導入使用，記住，包只是模塊的一種形式而已，包的本質就是一種模塊

 

二、爲什麼要使用包

　　包的本質就是一個文件夾，那麼文件夾惟一的功能就是將文件組織起來。隨着功能越寫越多，咱們沒法將因此功能都放到一個文件中，因而咱們使用模塊去組織功能，而隨着模塊愈來愈多，咱們就須要用文件夾將模塊文件組織起來，以此來提升程序的結構性和可維護性

 

三、注意事項

　　1.關於包相關的導入語句也分爲import和from ... import ...兩種，可是不管哪一種，不管在什麼位置，在導入時都必須遵循一個原則：凡是在導入時帶點的，點的左邊都必須是一個包，不然非法。能夠帶有一連串的點，如item.subitem.subsubitem,但都必須遵循這個原則。但對於導入後，在使用時就沒有這種限制了，點的左邊能夠是包,模塊，函數，類(它們均可以用點的方式調用本身的屬性)。

　　二、import導入文件時，產生名稱空間中的名字來源於文件，import 包，產生的名稱空間的名字一樣來源於文件，即包下的__init__.py，導入包本質就是在導入該文件

　　三、包A和包B下有同名模塊也不會衝突，如A.a與B.a來自倆個命名空間

 

四、包的使用

示範文件：

glance/                   #Top-level package
 ├── __init__.py      #Initialize the glance package
 ├── api #Subpackage for api
 │ ├── __init__.py │ ├── policy.py │ └── versions.py ├── cmd #Subpackage for cmd
 │ ├── __init__.py │ └── manage.py └── db #Subpackage for db
 ├── __init__.py └── models.py

#文件內容

#policy.py
def get(): print('from policy.py') #versions.py
def create_resource(conf): print('from version.py: ',conf) #manage.py
def main(): print('from manage.py') #models.py
def register_models(engine): print('from models.py: ',engine)

執行文件與示範文件在同級目錄下

包的使用之import 

import glance.db.models glance.db.models.register_models('mysql') 

單獨導入包名稱時不會導入包中全部包含的全部子模塊，如

#在與glance同級的test.py中
import glance glance.cmd.manage.main() ''' 執行結果： AttributeError: module 'glance' has no attribute 'cmd' '''

解決方法：

#glance/__init__.py 在glance包下的init文件中添加
from . import cmd #glance/cmd/__init__.py 在glance包下的cmd包下的init文件中添加
from . import manage

執行：

#在於glance同級的test.py中
import glance glance.cmd.manage.main()

 

包的使用之from ... import ...

須要注意的是from後import導入的模塊，必須是明確的一個不能帶點，不然會有語法錯誤，如：from a import b.c是錯誤語法

#示例：
from glance.db import models models.register_models('mysql') from glance.db.models import register_models register_models('mysql')

 

from glance.api import *

在講模塊時，咱們已經討論過了從一個模塊內導入全部*，此處咱們研究從一個包導入全部*。

此處是想從包api中導入全部，實際上該語句只會導入包api下__init__.py文件中定義的名字，咱們能夠在這個文件中定義__all___:

#在__init__.py中定義
x=10

def func(): print('from api.__init.py') __all__=['x','func','policy']

此時咱們在於glance同級的文件中執行from glance.api import *就導入__all__列表中的內容

#與包同級的執行文件中的使用效果以下
from glance import * get() create_resource('a.conf') main() register_models('mysql')

#在glance的__init__.py中
from .api.policy import get from .api.versions import create_resource from .cmd.manage import main from .db.models import register_models __all__=['get','create_resource','main','register_models']

 

五、絕對導入和相對導入

咱們的最頂級包glance是寫給別人用的，而後在glance包內部也會有彼此之間互相導入的需求，這時候就有絕對導入和相對導入兩種方式：

絕對導入：以glance做爲起始

相對導入：用.或者..的方式最爲起始（只能在一個包中使用，不能用於不一樣目錄內）

例如：咱們在glance/api/version.py中想要導入glance/cmd/manage.py

在glance/api/version.py #絕對導入
from glance.cmd import manage manage.main() #相對導入
from ..cmd import manage manage.main()

測試結果：注意必定要在於glance同級的文件中測試

 

包以及包所包含的模塊都是用來被導入的，而不是被直接執行的。而環境變量都是以執行文件爲準的

好比咱們想在glance/api/versions.py中導入glance/api/policy.py，有的人一看這倆模塊是在同一個目錄下，十分開心的就去作了，它直接這麼作

#在version.py中

import policy policy.get()

 

沒錯，咱們單獨運行version.py是一點問題沒有的，運行version.py的路徑搜索就是從當前路徑開始的，因而在導入policy時能在當前目錄下找到

可是，你子包中的模塊version.py極有多是被一個glance包同一級別的其餘文件導入，好比咱們在於glance同級下的一個test.py文件中導入version.py，以下

from glance.api import versions ''' 執行結果: ImportError: No module named 'policy' '''

''' 分析: 此時咱們導入versions在versions.py中執行 import policy須要找從sys.path也就是從當前目錄找policy.py, 這必然是找不到的 '''

 

解決辦法：使用相對導入和絕對導入都行