Python模塊化開發(fā)：構(gòu)建可重用、可維護的代碼
在現(xiàn)代軟件開發(fā)中，模塊化開發(fā)已成為一種不可或缺的方法。它不僅為我們構(gòu)建復(fù)雜的應(yīng)用程序提供了架構(gòu)上的便利，還能夠提高代碼的可重用性、可維護性和可擴展性。在Python這樣的高級編程語言中，模塊化開發(fā)的概念更是得到了廣泛的應(yīng)用。通過將代碼拆分為獨立的模塊，我們能夠更好地組織和管理代碼，讓我們的項目變得更加靈活、可測試和可維護。
一、自定義模塊
定義：一個模塊就是一個包含了python定義和聲明的文件，文件名就是模塊名字加上.py的后綴。封裝語句的最小單位，本質(zhì)就是.py文件。
自定義模塊：實際上就是定義.py,其中可以包含：變量定義，可執(zhí)行語句，for循環(huán)，函數(shù)定義等等，它們統(tǒng)稱模塊的成員。（模塊本身不宜過大，便于維護）
一個py文件拆分100文件,100個py文件又有相似相同的功能.冗余. 此時你要將100個py文件中相似相同的函數(shù)提取出來, input 功能,print()功能, time.time() os.path.....放在一個文件,當(dāng)你想用這個功能拿來即用.類似于這個py文件: 常用的相似的功能集合模塊。
模塊就是一個py文件常用的相似的功能集合。
1.模塊和包
import hashlib
def encrypt(data):
""" 數(shù)據(jù)加密 """
hash_object = hashlib.md5()
hash_object.update(data.encode('utf-8'))
return hash_object.hexdigest()
user = input("請輸入用戶名：")
pwd = input("請輸入密碼：")
md5_password = encrypt(pwd)
message = "用戶名：{}，密碼：{}".format(user, md5_password)
print(message)在開發(fā)簡單的程序時，使用一個py文件就可以搞定，如果程序比較龐大，需要10w行代碼，此時為了代碼結(jié)構(gòu)清晰，將功能按照某種規(guī)則拆分到不同的py文件中，使用時再去導(dǎo)入即可。另外，當(dāng)其他項目也需要此項目的某些模塊時，也可以直接把模塊拿過去使用，增加重用性。
如果按照某個規(guī)則進行拆分，發(fā)現(xiàn)拆分到 commons.py 中函數(shù)太多，也可以通過文件夾來進行再次拆分，例如：
├── commons
│ ├── convert.py
│ ├── page.py
│ └── utils.py
└── run.py在Python中一般對文件和文件的稱呼（很多開發(fā)者的平時開發(fā)中也有人都稱為模塊）：
- 一個py文件，模塊（module）。
- 含多個py文件的文件夾，包（package）。
注意：在包（文件夾）中有一個默認(rèn)內(nèi)容為空的__init__.py的文件，一般用于描述當(dāng)前包的信息（在導(dǎo)入他下面的模塊時，也會自動加載）。
- py2必須有，如果沒有導(dǎo)入包就會失敗。
- py3可有可無。
2. 導(dǎo)入
當(dāng)定義好一個模塊或包之后，如果想要使用其中定義的功能，必須要先導(dǎo)入，然后再能使用。
導(dǎo)入，其實就是將模塊或包加載的內(nèi)存中，以后再去內(nèi)存中去拿就行。
關(guān)于導(dǎo)如時的路徑：
在Python內(nèi)部默認(rèn)設(shè)置了一些路徑，導(dǎo)入模塊或包時，都會按照指定順序逐一去特定的路徑查找。
import sys
print(sys.path)[
'當(dāng)前執(zhí)行腳本所在的目錄', /Users/wupeiqi/PycharmProjects/luffyCourse/day14/bin
/Users/wupeiqi/PycharmProjects/luffyCourse/day14
'/Applications/PyCharm.app/Contents/plugins/python/helpers/pycharm_display',
'/Library/Frameworks/Python.framework/Versions/3.9/lib/python39.zip',
'/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9',
'/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/lib-dynload',
'/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages',
'/Applications/PyCharm.app/Contents/plugins/python/helpers/pycharm_matplotlib_backend'
]windows:
[
'C:\\Users\\Administrator\\Desktop\\pythonPro\\01.核心編程\\8.模塊',
'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python39\\python39.zip',
'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python39\\DLLs',
'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python39\\lib',
'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python39',
'C:\\Users\\Administrator\\AppData\\Roaming\\Python\\Python39\\site-packages',
'C:\\Users\\Administrator\\AppData\\Roaming\\Python\\Python39\\site-packages\\win32',
'C:\\Users\\Administrator\\AppData\\Roaming\\Python\\Python39\\site-packages\\win32\\lib',
'C:\\Users\\Administrator\\AppData\\Roaming\\Python\\Python39\\site-packages\\Pythonwin',
'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python39\\lib\\site-packages'
]想要導(dǎo)入任意的模塊和包，都必須寫在如下路徑下，才能被找到。
也可以自動手動在sys.path中添加指定路徑，然后再導(dǎo)入可以，例如：
import sys
sys.path.append("路徑A")
import xxxxx # 導(dǎo)入路徑A下的一個xxxxx.py文件你以后寫模塊名稱時，千萬不能和內(nèi)置和第三方的同名（新手容易犯錯誤）。
項目執(zhí)行文件一般都在項目根目錄，如果執(zhí)行文件嵌套的內(nèi)存目錄，就需要自己手動在sys.path中添加路徑。
pycharm中默認(rèn)會將項目目錄加入到sys.path中。
關(guān)于導(dǎo)入的方式：
導(dǎo)入本質(zhì)上是將某個文件中的內(nèi)容先加載到內(nèi)存中，然后再去內(nèi)存中拿過來使用。而在Python開發(fā)中常用的導(dǎo)入的方式有2類方式，每類方式都也多種情況。
第一類：import xxxx（開發(fā)中，一般多用于導(dǎo)入sys.path目錄下的一個py文件）
- 模塊級別
├── commons
│ ├── __init__.py
│ ├── convert.py
│ ├── page.py
│ ├── tencent
│ │ ├── __init__.py
│ │ ├── sms.py
│ │ └── wechat.py
│ └── utils.py
├── many.py
└── run.py- 包級別
├── commons
│ ├── __init__.py
│ ├── convert.py
│ ├── page.py
│ └── utils.py
├── third
│ ├── __init__.py
│ ├── ali
│ │ └── oss.py
│ └── tencent
│ ├── __init__.py
│ ├── __pycache__
│ ├── sms.py
│ └── wechat.py
└── run.py第二類：from xxx import xxx 【常用】，一般適用于多層嵌套和導(dǎo)入模塊中某個成員的情況。
成員級別：
├── commons
│ ├── __init__.py
│ ├── convert.py
│ ├── page.py
│ └── utils.py
├── many.py
└── run.py提示：基于from模式也可以支持 from many import *，即：導(dǎo)入一個模塊中所有的成員（可能會重名，所以用的少）。
模塊級別：
├── commons
│ ├── __init__.py
│ ├── convert.py
│ ├── page.py
│ └── utils.py
├── many.py
└── run.py包級別：
├── commons
│ ├── __init__.py
│ ├── convert.py
│ ├── page.py
│ ├── tencent
│ │ ├── __init__.py
│ │ ├── sms.py
│ │ └── wechat.py
│ └── utils.py
├── many.py
└── run.py3. 相對導(dǎo)入
在導(dǎo)入模塊時，對于 from xx import xx這種模式，還支持相對到導(dǎo)入。切記，相對導(dǎo)入只能用在包中的py文件中（即：嵌套在文件中的py文件才可以使用，項目根目錄下無法使用）。
4. 導(dǎo)入別名
如果項目中導(dǎo)入 成員/模塊/包 有重名，那么后導(dǎo)入的會覆蓋之前導(dǎo)入，為了避免這種情況的發(fā)生，Python支持重命名，即：
from xxx.xxx import xx as xo
import x1.x2 as pg除此之外，有了as的存在，讓 import xx.xxx.xxxx.xxx 在調(diào)用執(zhí)行時，會更加簡單（「不常用，了解即可」）。
原來：
import commons.page
v1 = commons.page.pagination()現(xiàn)在：
import commons.page as pg
v1 = pg.pagination()5. 主文件
執(zhí)行一個py文件時：
__name__ = "__main__"導(dǎo)入一個py文件時：
__name__ = "模塊名"主文件，其實就是在程序執(zhí)行的入口文件，例如：
├── commons
│ ├── __init__.py
│ ├── convert.py
│ ├── page.py
│ ├── tencent
│ │ ├── __init__.py
│ │ ├── sms.py
│ │ └── wechat.py
│ └── utils.py
├── many.py
└── run.py我們通常是執(zhí)行 run.py 去運行程序，其他的py文件都是一些功能代碼。當(dāng)我們?nèi)?zhí)行一個文件時，文件內(nèi)部的 __name__變量的值為 main，所以，主文件經(jīng)常會看到：
import many
from commons import page
from commons import utils
def start():
v1 = many.show()
v2 = page.pagination()
v3 = utils.encrypt()
if __name__ == '__main__':
start()只有是以主文件的形式運行此腳本時start函數(shù)才會執(zhí)行，被導(dǎo)入時則不會被執(zhí)行。
二、第三方模塊
第三方模塊6000種左右，pip install 需要這個指令安裝的模塊,Beautiful_soup,request,Django,flask 等等。Python內(nèi)部提供的模塊有限，所以在平時在開發(fā)的過程中，經(jīng)常會使用第三方模塊。而第三方模塊必須要先安裝才能可以使用，下面介紹常見的3中安裝第三方模塊的方式。其實，使用第三方模塊的行為就是去用別人寫好并開源出來的py代碼，這樣自己拿來就用，不必重復(fù)造輪子了。。。。
1. pip（最常用）
這是Python中最最最常用的安裝第三方模塊的方式。
pip其實是一個第三方模塊包管理工具，默認(rèn)安裝Python解釋器時自動會安裝，默認(rèn)目錄：
MAC系統(tǒng)，即：Python安裝路徑的bin目錄下
/Library/Frameworks/Python.framework/Versions/3.9/bin/pip3
/Library/Frameworks/Python.framework/Versions/3.9/bin/pip3.9
Windows系統(tǒng)，即：Python安裝路徑的scripts目錄下
C:\Python39\Scripts\pip3.exe
C:\Python39\Scripts\pip3.9.exe提示：為了方便在終端運行pip管理工具，我們也會把它所在的路徑添加到系統(tǒng)環(huán)境變量中。
pip3 install 模塊名稱默認(rèn)安裝的是最新的版本，如果想要指定版本：
pip3 install 模塊名稱==版本
例如：
pip3 install django==2.2(1) pip更新
上圖的黃色字體提示：目前我電腦上的pip是20.2.3版本，最新的是 20.3.3 版本，如果想要升級為最新的版本，可以在終端執(zhí)行他提示的命令：
/Library/Frameworks/Python.framework/Versions/3.9/bin/python3.9 -m pip install --upgrade pip注意：根據(jù)自己電腦的提示命令去執(zhí)行，不要用我這里的提示命令哈。
(2) 豆瓣源
pip默認(rèn)是去 https://pypi.org 去下載第三方模塊（本質(zhì)上就是別人寫好的py代碼），國外的網(wǎng)站速度會比較慢，為了加速可以使用國內(nèi)的豆瓣源。因此可以設(shè)置鏡像源的方式：
一次性使用：
pip3.9 install 模塊名稱 -i https://pypi.douban.com/simple/永久使用（配置）：
# 在終端執(zhí)行如下命令
pip3.9 config set global.index-url https://pypi.douban.com/simple/
# 執(zhí)行完成后，提示在我的本地文件中寫入了豆瓣源，以后再通過pip去安裝第三方模塊時，就會默認(rèn)使用豆瓣源了。
# 自己以后也可以打開文件直接修改源地址。
Writing to /Users/wupeiqi/.config/pip/pip.conf寫在最后，也還有其他的源可供選擇（豆瓣應(yīng)用廣泛）：
阿里云：http://mirrors.aliyun.com/pypi/simple/
中國科技大學(xué)：https://pypi.mirrors.ustc.edu.cn/simple/
清華大學(xué)：https://pypi.tuna.tsinghua.edu.cn/simple/
中國科學(xué)技術(shù)大學(xué)：http://pypi.mirrors.ustc.edu.cn/simple/2. 其他方式
(1) 源碼
如果要安裝的模塊在pypi.org中不存在 或 因特殊原因無法通過pip install 安裝時，可以直接下載源碼，然后基于源碼安裝，由于這種方式比較繁瑣，這里有想法的可以自己去探索。
(2) 基于wheel
wheel是Python的第三方模塊包的文件格式的一種，我們也可以基于wheel去安裝一些第三方模塊。安裝wheel格式支持，這樣pip再安裝第三方模塊時，就可以處理wheel格式的文件了。
pip3.9 install wheel下載第三方的包（wheel格式），例如：
進入下載目錄，在終端基于pip直接安裝：
pip3 install requests-2.25.1-py2.py3-none-any.whl無論通過什么形式去安裝第三方模塊，默認(rèn)模塊的安裝路徑在：
Max系統(tǒng)：
/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages
Windows系統(tǒng)：
C:\Python39\Lib\site-packages\提醒：這個目錄在sys.path中，所以我們直接在代碼中直接導(dǎo)入下載的第三方包是沒問題的。
三、內(nèi)置模塊
內(nèi)置模塊200種左右，python解釋器自帶的模塊，time os sys hashlib等等。
Python內(nèi)置的模塊有很多，我們也已經(jīng)接觸了不少相關(guān)模塊，接下來咱們就來做一些匯總和介紹。
內(nèi)置模塊有很多 & 模塊中的功能也非常多，我們是沒有辦法注意全局給大家講解，在此我會整理出項目開發(fā)最常用的來進行講解。
1.os模塊
OS提供了一些關(guān)于文件操作的功能：
import os
# 1. 獲取當(dāng)前腳本絕對路徑
abs_path = os.path.abspath(__file__)
print(abs_path)
# 2. 獲取當(dāng)前文件的上級目錄
base_path = os.path.dirname( os.path.dirname(路徑) ）
print(base_path)
# 3. 路徑拼接
p1 = os.path.join(base_path, 'xx')
print(p1)
p2 = os.path.join(base_path, 'xx', 'oo', 'a1.png')
print(p2)
# 4. 判斷路徑是否存在
exists = os.path.exists(p1)
print(exists)
# 5. 創(chuàng)建文件夾
os.makedirs(路徑)
path = os.path.join(base_path, 'xx', 'oo', 'uuuu')
if not os.path.exists(path):
os.makedirs(path)
# 6. 是否是文件夾
file_path = os.path.join(base_path, 'xx', 'oo', 'uuuu.png')
is_dir = os.path.isdir(file_path)
print(is_dir) # False
folder_path = os.path.join(base_path, 'xx', 'oo', 'uuuu')
is_dir = os.path.isdir(folder_path)
print(is_dir) # True
# 7. 刪除文件或文件夾
os.remove("文件路徑")2. random
此模塊提供了和隨機數(shù)獲取相關(guān)的方法：
- random.random()：獲取從[0.0 , 1.0) 范圍內(nèi)的浮點數(shù)。
improt random
print(random.random())
# 0.8595089778726372- random.randint(a,b)：獲取[a,b] 范圍內(nèi)的整數(shù)。
print(random.randint(3,10))- random.uniform(a,b)：獲取[a,b) 范圍內(nèi)的浮點數(shù)。 取決于操作系統(tǒng)
print(random.uniform(3,5))- random.shuffle(x)：把參數(shù)指定的數(shù)據(jù)中的元素打亂，其中參數(shù)必須是可變數(shù)據(jù)類型。混洗。（直接修改原列表）
lst = list(range(10))
random.shuffle(lst)
print(lst)
# [4, 6, 2, 7, 0, 8, 9, 3, 5, 1]- random.choice(seq)：函數(shù)可以從非空序列中取出一個隨機元素。
alist = list('abcdef')
random.choice(alist)- random.choices(population, weights=None, *, cum_weights=None, k=1)函數(shù)可以從總體中隨機抽?。ㄓ蟹呕爻闃樱┏鋈萘繛閗的樣本并返回樣本的列表，可以通過參數(shù)指定個體的權(quán)重，如果沒有指定權(quán)重，個體被選中的概率均等。
random.choices(alist,k=4)
# ['b', 'f', 'b', 'f']- random.sample(x,k)：從x中隨機取k個數(shù)據(jù)，組成一個列表返回。 （從不可變數(shù)據(jù)類型中?。ㄗ兿啻騺y元組，數(shù)據(jù)）
t = (1,2,3)
lst = random.sample(t,len(t))
print(lst)小應(yīng)用：驗證碼
import random
def get_random_code(length=6):
data = []
for i in range(length):
v = random.randint(65,90)
data.append(chr(v))
return ''.join(data)
code = get_random_code()
print(code)關(guān)于內(nèi)置模塊還有很多，這里我們不做更多的介紹，會在后面繼續(xù)更新...
四、項目開發(fā)規(guī)范
現(xiàn)階段，我們在開發(fā)一些程序時（終端運行），應(yīng)該遵循一些結(jié)構(gòu)的規(guī)范，讓你的系統(tǒng)更加專業(yè)。
1. 單文件應(yīng)用
當(dāng)基于python開發(fā)簡單應(yīng)用時（一個py文件就能搞定），需要注意如下幾點。
"""
1.文件注釋
"""
# 2.導(dǎo)包（內(nèi)置，第三方，自定義）
import re
import random
import requests
from openpyxl import load_workbook
# 3.全局變量大寫
DB = "XXX"
# 4.函數(shù)名規(guī)范，函數(shù)功能注釋
def do_something():
""" 函數(shù)注釋 """
# TODO # 5.待完成時，下一期實現(xiàn)xxx功能
for i in range(10):
pass
def run():
""" 函數(shù)注釋 """
# 對功能代碼進行注釋 # 6.部分功能代碼注釋
text = input(">>>")
print(text)
# 7.主文件
if __name__ == '__main__':
run()2. 單可執(zhí)行文件
新創(chuàng)建一個項目，假設(shè)名字叫 【crm】，可以創(chuàng)建如下文件和文件夾來存放代碼和數(shù)據(jù)。
crm
├── app.py 文件，程序的主文件（盡量精簡）
├── config.py 文件，配置文件（放相關(guān)配置信息，代碼中讀取配置信息，如果想要修改配置，即可以在此修改，不用再去代碼中逐一修改了）
├── db 文件夾，存放數(shù)據(jù)
├── files 文件夾，存放文件
├── src 包，業(yè)務(wù)處理的代碼
└── utils 包，公共功能3. 多可執(zhí)行文件
新創(chuàng)建項目，假設(shè)名稱叫【killer】，可以創(chuàng)建如下文件和文件夾來存放代碼和數(shù)據(jù)。
killer
├── bin 文件夾，存放多個主文件（可運行）
│ ├── app1.py
│ └── app2.py
├── config 包，配置文件
│ ├── __init__.py
│ └── settings.py
├── db 文件夾，存放數(shù)據(jù)
├── files 文件夾，存放文件
├── src 包，業(yè)務(wù)代碼
│ └── __init__.py
└── utils 包，公共功能
└── __init__.py4. 項目結(jié)構(gòu)
設(shè)計項目目錄結(jié)構(gòu)的作用：
- 可讀性高: 不熟悉這個項目代碼的人，一眼就能看懂目錄結(jié)構(gòu)，知道程序啟動腳本是哪個，測試目錄在哪兒，配置文件在哪兒等等。從而非常快速的了解這個項目。
- 可維護性高: 定義好組織規(guī)則后，維護者就能很明確地知道，新增的哪個文件和代碼應(yīng)該放在什么目錄之下。這個好處是，隨著時間的推移，代碼/配置的規(guī)模增加，項目結(jié)構(gòu)不會混亂，仍然能夠組織良好。
較好的目錄結(jié)構(gòu)方式（推薦）
- bin是一個存放啟動文件的目錄,不管你文件的名字叫什么你只要放到bin目錄下大家就知道這是一個啟動文件：
#===============>start.py
# 開啟項目的start文件。
import sys,os
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
from core import src
if __name__ == '__main__':
src.run()- cores是一個存放項目的主邏輯,比如購物車,里邊寫的就是登陸充值購買等功能；
#===============>src.py
# 主要邏輯部分：
# 核心邏輯，代碼放在這。
from conf import settings
from lib import common
import time
logger=common.get_logger(__name__)
current_user={'user':None,'login_time':None,'timeout':int(settings.LOGIN_TIMEOUT)}
def auth(func):
def wrapper(*args,**kwargs):
pass
return wrapper
@auth
def buy():
print('buy...')
@auth
def run():
print('''
購物
查看余額
轉(zhuǎn)賬- lib是存放有一個公共組件的目錄,什么是公共組件,就是在這個項目中陪別的功能頻繁使用的功能；
#===============>common.py
# 公共組件放在這里：公共功能部分。
from conf import settings
import logging
import logging.config
import json
def get_logger(name):
logging.config.dictConfig(settings.LOGGING_DIC) # 導(dǎo)入上面定義的logging配置
logger = logging.getLogger(name) # 生成一個log實例
return logger
def conn_db():
db_path=settings.DB_PATH
dic=json.load(open(db_path,'r',encoding='utf-8'))
return dic- conf 是一個存放配置文件的目錄,配置文件就是文件中的一些全局變量移到這里；
#===============>settings.py
# 配置文件，放一些路徑或者信息等配置
import os
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DB_PATH=os.path.join(BASE_DIR,'db','db.json')
LOG_PATH=os.path.join(BASE_DIR,'log','access.log')
LOGIN_TIMEOUT=5- db是存放這個項目需要使用到的一些文件；
// ===============>db.json
// 重要數(shù)據(jù)放在這里
{
"students":[
{"name":"lisa","age":18},
{"name":"jack","age":18},
// ...
]
}- log是這個項目需要記錄的日志文件存放位置；
"""
logging配置
"""
# 定義三種日志輸出格式
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]' #其中name為getlogger指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
# log配置字典
LOGGING_DIC = {
# xxx
}5. 關(guān)于README的內(nèi)容
每個項目都應(yīng)該有的一個文件，目的是能簡要描述該項目的信息，讓讀者快速了解這個項目。它需要說明以下幾個事項:
- 軟件定位，軟件的基本功能。
- 運行代碼的方法: 安裝環(huán)境、啟動命令等。
- 簡要的使用說明。
- 代碼目錄結(jié)構(gòu)說明，更詳細點可以說明軟件的基本原理。
- 常見問題說明。
五、總結(jié)
模塊化開發(fā)是Python編程中的一個重要實踐。通過將代碼分解為獨立的模塊，我們可以更好地管理、組織和復(fù)用代碼。模塊化開發(fā)使得我們的項目更易于擴展、維護和測試，并且還可以加速開發(fā)過程。在實際應(yīng)用中，我們可以采用各種技術(shù)和工具來實現(xiàn)模塊化開發(fā)，如使用Python的內(nèi)置模塊、第三方庫、包管理工具等。通過運用模塊化開發(fā)的原則和技巧，我們能夠編寫出結(jié)構(gòu)清晰、易于理解和更具可持續(xù)性的Python代碼。
