<div id="page_begin_html">
    <script>loadPageBeginHtml();</script>
</div>
<!--done-->
 

太白金星

</div><!--end: blogTitle 部落格的標題和副標題 -->
<div id="navigator">

• 部落格園
• 首頁
• 新隨筆
• 聯絡
• 訂閱
• 管理

	<div class="blogStats">
		<span id="stats_post_count">隨筆 - 6&nbsp; </span>

文章 - 121
評論 - 239

	</div><!--end: blogStats -->
</div><!--end: navigator 部落格導航欄 -->

自定義模組

        </h1>
        <div class="clear"></div>
        <div class="postBody">

1. 模組的定義與分類

模組是什麼？

這幾天，我們進入模組的學習。在學習模組之前，我們首先要知道，什麼是模組？

一個函式封裝一個功能，你使用的軟體可能就是由n多個函式組成的（先備考慮面向物件）。比如抖音這個軟體，不可能將所有程式都寫入一個檔案，所以咱們應該將檔案劃分，這樣其組織結構要好並且程式碼不冗餘。加入分了10個檔案，每個檔案裡面可能都有相同的功能（函式），怎麼辦？所以將這些相同的功能封裝到一個檔案中，那麼這個儲存著很多常用的功能的py檔案，就是模組。 模組就是檔案，存放一堆常用的函式，誰用誰拿。怎麼拿？比如：我要策馬奔騰共享人世繁華，應該怎麼樣？我應該騎馬，你也要去浪，你是不是也要騎馬。 我們說一個函式就是一個功能，那麼把一些常用的函式放在一個py檔案中，這個檔案就稱之為模組，模組，就是一些列常用功能的集合體。

為什麼要使用模組?

1. 從檔案級別組織程式，更方便管理 隨著程式的發展，功能越來越多，為了方便管理，我們通常將程式分成一個個的檔案，這樣做程式的結構更清晰，方便管理。這時我們不僅僅可以把這些檔案當做指令碼去執行，還可以把他們當做模組來匯入到其他的模組中，實現了功能的重複利用

2. 拿來主義，提升開發效率 同樣的原理，我們也可以下載別人寫好的模組然後匯入到自己的專案中使用，這種拿來主義，可以極大地提升我們的開發效率，避免重複造輪子。

ps：人們常說的指令碼是什麼？

如果你退出python直譯器然後重新進入，那麼你之前定義的函式或者變數都將丟失，因此我們通常將程式寫到檔案中以便永久儲存下來，需要時就通過python test.py方式去執行，此時test.py被稱為指令碼script。

所以，指令碼就是一個python檔案，比如你之前寫的購物車，模擬部落格園登入系統的檔案等等。

模組的分類

Python語言中，模組分為三類。

第一類：內建模組，也叫做標準庫。此類模組就是python直譯器給你提供的，比如我們之前見過的time模組,os模組。標準庫的模組非常多（200多個，每個模組又有很多功能），我們這幾天就講常用的十幾種，後面課程中還會陸續的講到。

第二類：第三方模組，第三方庫。一些python大神寫的非常好用的模組，必須通過pip install 指令安裝的模組，比如BeautfulSoup, Django,等等。大概有6000多個。

第三類：自定義模組。我們自己在專案中定義的一些模組。

這幾天，我們先學第一類和第三類模組，第二類模組會在我們併發程式設計開始逐漸的接觸學習。

今天，我們先講第三類，自定義模組。

我們先定義一個模組，定義一個模組其實很簡單就是寫一個檔案，裡面寫一些程式碼（變數，函式）即可。此檔案的名字為tbjx.py，檔案內容如下：

print('from the tbjx.py')
name = '太白金星'
​
def read1():
    print('tbjx模組：',name)
​
def read2():
    print('tbjx模組')
    read1()
​
def change():
    global name
    name = 'barry'

2. import

2.1 import 使用

import 翻譯過來是一個匯入的意思。

這裡一定要給同學強調那個檔案執行檔案，和哪個檔案是被執行模組。

模組可以包含可執行的語句和函式的定義，這些語句的目的是初始化模組，它們只在模組名第一次遇到匯入import語句時才執行（import語句是可以在程式中的任意位置使用的,且針對同一個模組很import多次,為了防止你重複匯入，python的優化手段是：第一次匯入後就將模組名載入到記憶體了，後續的import語句僅是對已經載入到記憶體中的模組物件增加了一次引用，不會重新執行模組內的語句），如下 ​import tbjx #只在第一次匯入時才執行tbjx.py內程式碼,此處的顯式效果是隻列印一次'from the tbjx.py',當然其他的頂級程式碼也都被執行了,只不過沒有顯示效果.

程式碼示例：
import tbjx

import tbjx

import tbjx

import tbjx

import tbjx

​

​

執行結果：只是列印一次：

from the tbjx.py

2.2 第一次匯入模組執行三件事

1.建立一個以模組名命名的名稱空間。

2.執行這個名稱空間（即匯入的模組）裡面的程式碼。

3.通過此模組名. 的方式引用該模組裡面的內容（變數，函式名，類名等）。 這個名字和變數名沒什麼區別，都是‘第一類的’，且使用tbjx.名字的方式可以訪問tbjx.py檔案中定義的名字，tbjx.名字與test.py中的名字來自兩個完全不同的地方。

ps：重複匯入會直接引用記憶體中已經載入好的結果

2.3 被匯入模組有獨立的名稱空間

每個模組都是一個獨立的名稱空間，定義在這個模組中的函式，把這個模組的名稱空間當做全域性名稱空間，這樣我們在編寫自己的模組時，就不用擔心我們定義在自己模組中全域性變數會在被匯入時，與使用者的全域性變數衝突。

示例：

當前是meet.py
import tbjx.py

name = 'alex'

print(name)

print(tbjx.name)

'''

from the tbjx.py

alex

太白金星

'''

​

def read1():

print(666)

tbjx.read1()

'''

from the tbjx.py

tbjx模組： 太白金星

'''

​

name = '日天'

tbjx.change()

print(name)

print(tbjx.name)

'''

from the tbjx.py

日天

barry

'''

讓同學們將上面的程式碼練習一下。

2.4 為模組起別名

別名其實就是一個外號,我們小的時候，都喜歡給學生們起外號對吧。

1. 好處可以將很長的模組名改成很短,方便使用.

import tbjx as t
t.read1()

2. 有利於程式碼的擴充套件和優化。

#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()

2.5 匯入多個模組

我們以後再開發過程中，免不了會在一個檔案中，匯入多個模組，推薦寫法是一個一個匯入。

import os,sys,json   # 這樣寫可以但是不推薦
​
推薦寫法
​
import os
import sys
import json

　　多行匯入：易於閱讀 易於編輯 易於搜尋 易於維護。

3 from ... import ...

3.1 from ... import ... 使用

from ... import ... 的使用示例。
from tbjx import name, read1

print(name)

read1()

'''

執行結果：

from the tbjx.py

太白金星

tbjx模組： 太白金星

​

'''

3.2 from...import... 與import對比

唯一的區別就是：使用from...import...則是將spam中的名字直接匯入到當前的名稱空間中，所以在當前名稱空間中，直接使用名字就可以了、無需加字首：tbjx.

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

好處：使用起來方便了

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

示例演示：

1. 執行檔案有與模組同名的變數或者函式名，會有覆蓋效果。

name = 'oldboy'
from tbjx import name, read1, read2
print(name)  
'''
執行結果：
太白金星
'''
----------------------------------------
from tbjx import name, read1, read2
name = 'oldboy'
print(name)  
​
'''
執行結果：
oldboy
​
'''
----------------------------------------
def read1():
    print(666)
from tbjx import name, read1, read2
read1()
​
'''
執行結果：
tbjx模組： 太白金星
'''
----------------------------------------
​
from tbjx import name, read1, read2
def read1():
    print(666)
read1()
​
'''
執行結果：
tbjx模組： 666
'''

　2. 當前位置直接使用read1和read2就好了，執行時，仍然以tbjx.py檔案全域性名稱空間

#測試一：匯入的函式read1，執行時仍然回到tbjx.py中尋找全域性變數 'alex'
#test.py
from tbjx import read1
name = 'alex'
read1()
'''
執行結果:
from the spam.py
spam->read1->name = '太白金星'
'''
​
#測試二:匯入的函式read2，執行時需要呼叫read1(),仍然回到tbjx.py中找read1()
#test.py
from tbjx import read2
def read1():
    print('==========')
read2()
​
'''
執行結果:
from the tbjx.py
tbjx->read2 calling read
tbjx->read1->tbjx 'barry'
'''
    4.3.3 也支援as
通過這種方式引用模組也可以對模組進行改名。
from tbjx import read1 as read

read()

3.4 一行匯入多個

from tbjx import read1,read2,name

3.5 from ... import *

from spam import * 把tbjx中所有的不是以下劃線(_)開頭的名字都匯入到當前位置

大部分情況下我們的python程式不應該使用這種匯入方式，因為*你不知道你匯入什麼名字，很有可能會覆蓋掉你之前已經定義的名字。而且可讀性極其的差，在互動式環境中匯入時沒有問題。

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

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

3.6 模組迴圈匯入問題

模組迴圈/巢狀匯入丟擲異常的根本原因是由於在python中模組被匯入一次之後，就不會重新匯入，只會在第一次匯入時執行模組內程式碼

在我們的專案中應該儘量避免出現迴圈/巢狀匯入，如果出現多個模組都需要共享的資料，可以將共享的資料集中存放到某一個地方在程式出現了迴圈/巢狀匯入後的異常分析、解決方法如下（瞭解，以後儘量避免）

示範檔案內容如下

#建立一個m1.py
print('正在匯入m1')
from m2 import y
​
x='m1'
​
#建立一個m2.py
print('正在匯入m2')
from m1 import x
​
y='m2'
​
#建立一個run.py
import m1
​
#測試一
執行run.py會丟擲異常
正在匯入m1
正在匯入m2
Traceback (most recent call last):
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa練習目錄/aa.py", line 1, in <module>
    import m1
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa練習目錄/m1.py", line 2, in <module>
    from m2 import y
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa練習目錄/m2.py", line 2, in <module>
    from m1 import x
ImportError: cannot import name 'x'
​
​
#測試一結果分析
先執行run.py--->執行import m1，開始匯入m1並執行其內部程式碼--->列印內容"正在匯入m1"
--->執行from m2 import y 開始匯入m2並執行其內部程式碼--->列印內容“正在匯入m2”--->執行from m1 import x,由於m1已經被匯入過了，所以不會重新匯入，所以直接去m1中拿x，然而x此時並沒有存在於m1中，所以報錯
​
​
#測試二:執行檔案不等於匯入檔案，比如執行m1.py不等於匯入了m1
直接執行m1.py丟擲異常
正在匯入m1
正在匯入m2
正在匯入m1
Traceback (most recent call last):
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa練習目錄/m1.py", line 2, in <module>
    from m2 import y
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa練習目錄/m2.py", line 2, in <module>
    from m1 import x
  File "/Users/linhaifeng/PycharmProjects/pro01/1 aaaa練習目錄/m1.py", line 2, in <module>
    from m2 import y
ImportError: cannot import name 'y'
​
​
#測試二分析
執行m1.py，列印“正在匯入m1”，執行from m2 import y ，匯入m2進而執行m2.py內部程式碼--->列印"正在匯入m2"，執行from m1 import x，此時m1是第一次被匯入，執行m1.py並不等於匯入了m1，於是開始匯入m1並執行其內部程式碼--->列印"正在匯入m1"，執行from m1 import y，由於m1已經被匯入過了，所以無需繼續匯入而直接問m2要y，然而y此時並沒有存在於m2中所以報錯
​
​
​
# 解決方法:
方法一:匯入語句放到最後
#m1.py
print('正在匯入m1')
​
x='m1'
​
from m2 import y
​
#m2.py
print('正在匯入m2')
y='m2'
​
from m1 import x
​
方法二:匯入語句放到函式中
#m1.py
print('正在匯入m1')
​
def f1():
    from m2 import y
    print(x,y)
​
x = 'm1'
​
# f1()
​
#m2.py
print('正在匯入m2')
​
def f2():
    from m1 import x
    print(x,y)
​
y = 'm2'
​
#run.py
import m1
​
m1.f1()

4. py檔案的兩種功能

編寫好的一個python檔案可以有兩種用途：
一：指令碼，一個檔案就是整個程式，用來被執行（比如你之前寫的模擬部落格園登入那個作業等）
二：模組，檔案中存放著一堆功能，用來被匯入使用
​
python為我們內建了全域性變數__name__，
當檔案被當做指令碼執行時：__name__ 等於'__main__'
當檔案被當做模組匯入時：__name__等於模組名
​
#作用：用來控制.py檔案在不同的應用場景下執行不同的邏輯（或者是在模組檔案中測試程式碼）

if __name__ == '__main__':

print('from the tbjx.py')
​
__all__ = ['name', 'read1',]
​
name = '太白金星'
​
​
def read1():
   print('tbjx模組：',name)
​
​
def read2():
   print('tbjx模組')
   read1()
​
​
def change():
global name

name = 'barry'
if name == 'main':

# 在模組檔案中測試read1()函式

# 此模組被匯入時 name == tbjx 所以不執行

read1()

5. 模組的搜尋路徑

當你引用一個模組時，不見得每次都可以import到：

上面的示例可以得知，引用模組也是按照一定規則進行引用的。

Python中引用模組是按照一定的規則以及順序去尋找的，這個查詢順序為：先從記憶體中已經載入的模組進行尋找找不到再從內建模組中尋找，內建模組如果也沒有，最後去sys.path中路徑包含的模組中尋找。它只會按照這個順序從這些指定的地方去尋找，如果最終都沒有找到，那麼就會報錯。

記憶體中已經載入的模組->內建模組->sys.path路徑中包含的模組

模組的查詢順序

1. 在第一次匯入某個模組時（比如tbjx），會先檢查該模組是否已經被載入到記憶體中（當前執行檔案的名稱空間對應的記憶體），如果有則直接引用（ps：python直譯器在啟動時會自動載入一些模組到記憶體中，可以使用sys.modules檢視）

2. 如果沒有，直譯器則會查詢同名的內建模組

3. 如果還沒有找到就從sys.path給出的目錄列表中依次尋找tbjx.py檔案。

需要特別注意的是：我們自定義的模組名不應該與系統內建模組重名。雖然每次都說，但是仍然會有人不停的犯錯

#在初始化後，python程式可以修改sys.path,路徑放到前面的優先於標準庫被載入。
​
> > > import sys
> > > sys.path.append('/a/b/c/d')
> > > sys.path.insert(0,'/x/y/z') #排在前的目錄，優先被搜尋
> > > 注意：搜尋時按照sys.path中從左到右的順序查詢，位於前的優先被查詢，sys.path中還可能包含.zip歸檔檔案和.egg檔案，python會把.zip歸檔檔案當成一個目錄去處理，
​
#首先製作歸檔檔案：zip module.zip foo.py bar.py 
import sys
sys.path.append('module.zip')
import foo,bar
​
#也可以使用zip中目錄結構的具體位置
sys.path.append('module.zip/lib/python')
​
#windows下的路徑不加r開頭，會語法錯誤
sys.path.insert(0,r'C:\Users\Administrator\PycharmProjects\a')
​
#至於.egg檔案是由setuptools建立的包，這是按照第三方python庫和擴充套件時使用的一種常見格式，.egg檔案實際上只是添加了額外元資料(如版本號，依賴項等)的.zip檔案。
​
#需要強調的一點是：只能從.zip檔案中匯入.py，.pyc等檔案。使用C編寫的共享庫和擴充套件塊無法直接從.zip檔案中載入（此時setuptools等打包系統有時能提供一種規避方法），且從.zip中載入檔案不會建立.pyc或者.pyo檔案，因此一定要事先建立他們，來避免載入模組是效能下降。

接下來我們就開始講解python常用的內建模組，由於Python常用的模組非常多，我們不可能將所有的模組都講完， 所以只針對於工作中經常用到模組進行講解。剩下的模組可以在課餘時間自學。