一 Python模塊簡介
1 模塊化
一般來說,編程語言中,庫,包,模塊是同一種概念,是代碼組織方式
python中只有一種模塊對象類型,但是為了模塊化組織的便利,提供了一個概念: 包
模塊(module):指的是python的源代碼文件
包(package):指的是模塊組織在一起放入和包名同名的目錄及相關文件
可以將代碼量較大的程序分割成多個有組織,彼此間獨立但又能互相交互的代碼片段,這些自我包含的有組織的代碼段就是模塊
模塊在物理形式上表現為以.py 結尾的代碼文件
一個文件被看做一個獨立的模塊,一個模塊也可以被看做是一個文件
模塊的文件名就是模塊的名字加上擴展名.py
2 模塊名稱空間
每個模塊都有自己的名稱空間
Python 允許“導入”其他模塊以實現代碼重用,從而也實現了將獨立的代碼文件組織成更大的程序系統
Python 中,模塊也是對象
在一個模塊的頂層定義(全局變量)的所有變量都在被導入時成為了被導入模塊的屬性
3 頂層文件和模塊文件
一個Python程序通常包括一個頂層文件和其他的模塊文件(0個,1個或多個)
頂層文件:包含了程序的主要控制流程
模塊文件:為頂層文件或其他模塊提供各種功能性組件
模塊首次導入(或重載)時,Python會立即執行模塊文件的頂層程序代碼(不在函數內的代碼),而位于函數體內的代碼直到函數被調用后才會執行
Python自帶的模塊稱為Python的標準庫模塊
二 import 和 from .. import 及自定義模塊
1 import 導入語句
語句 | 含義 |
---|---|
import 模塊1[,模塊2,...] | 完全導入 |
import ... as ... | 模塊別名 |
具體操作:
import 語句
1 找到指定模塊,初始化和加載它至內存中,若找不到,則拋出異常ImportError
2 import 所在的作用域的局部名稱空間中,增加了名稱和上一步創建的對象的關聯(在某個函數內部寫的impoer中的作用域中)
總結: 在當前模塊中導入另一個模塊,找到單獨加載,單獨初始化,生成模塊對象,在自己的作用域內生成名稱,將對象和名稱進行映射,那個對象是單獨生成的,和本模塊(import所在的模塊)沒有多大關系,只是名稱和其對象進行了映射
獲取指定名稱來收集對象的屬性和方法
獲取import 導入os.path的結果 ,此處只導入了os模塊
as 重名稱
總結 :
導入頂級模塊,其名稱對應的標識符加入到本地名稱空間中,并綁定到初始化后的模塊的位置
導入非頂級模塊,其頂級模塊對應的名稱標識符會加入到本地名稱空間中,導入的模塊必須使用完全限定名成來訪問
如果使用了as,其后面的名稱會直接載入到本地名稱空間中,并直接綁定到導入的模塊對象
2 部分導入 (from ... import ...)
1 語法
語句 | 含義 |
---|---|
from ... import | 部分導入 |
from ... import ... as ... | 別名 |
2 導入
import 本質上只能導入模塊。而from中可以對模塊中的屬性和方法內容進行導入操作
但其本質上還是將from中指定的模塊全部都進行了初始化和加載操作
3 as 字句的使用
4 總結
找到from子句中指定的模塊,加載并初始化它(注意不是導入)
對于impoer字句后面的名稱
1 先查看from字句導入的模塊是否具有該名稱屬性
2 如果不是,則嘗試導入該名稱的子模塊
3 還沒有找到,則拋出ImportError異常
4 這個名稱保存到本地名稱空間中,如果有as字句,則使用as字句后的名稱
3 自定義模塊
1 自定義模塊test
2 import 方式導入模塊,其名詞邊界是模塊,不是方法或屬性。
3 from ... import ... 方式導入模塊
4 自定義模塊命名規范:
1 模塊名就是文件名
2 模塊名必須符合標識符要求,非數字開頭的數字,字母或下劃線,不能是其他
3 不要使用系統模塊,以避免沖突,除非你明確知道這個模塊名的用途
4 通常模塊名為全小寫,下劃線來分割
三 模塊相關屬性
1 模塊的搜索順序
使用sys.path 來查看模塊的搜索順序
顯示結果為python模塊的路徑搜索順序
當加載一個模塊的時候,需要從這些模塊搜索路徑中從前向后一次查找,不搜索這些目錄的子目錄,搜索到就進行加載,搜索不到就拋出異常路徑可以是字典,zip文件,egg文件
.egg文件,由setuptools庫創建的包,第三方常用的格式,添加了元數據(版本號,依賴項等)信息的zip文件
路徑順序為
程序主目錄,程序運行的主程序腳本所在的目錄
PYTHONPATH 目錄,環境變量PYTHONPATH設置的目錄也是搜索模塊的路徑
標準庫目錄,python自帶的庫摩克所在目錄sys.path 是列表,可以被修改,Linux本身是走PATH,因此需要加上./x 而Windows本身路徑就攜帶./
2 模塊的重復導入
模塊是不可以重復被導入的,重復導入是在浪費內存,其是在sys.modules中
從執行結果來看,不會產生重復導入的現象
所有加載的模塊都會記錄在sys.modules中。sys.modules存儲已經加載過所有模塊的字典
3 模塊的運行
_ name_ 每個模塊都會定義一個_ name_ 特殊變量來存儲當前模塊的名稱,如果不指定,默認為源代碼文件名詞,如果有包則有限定名
解釋器初始化的時候,會初始化字典sys.modules(保存已加載的模塊),創建Builtins(全局函數,常量)模塊、__main__模塊,sys模塊,以及模塊搜索路徑sys.path
python是腳本語言,任何一個腳本都可以直接執行,也可以作為模塊被導入。
如果一個模塊能夠被執行,則就是main模塊
當從標準輸入(命令行方式敲代碼),腳本或交互式讀取的時候,會將模塊的_ name__設置為_ main\ ,模塊的頂層代碼就在_ main__這個作用域中執行,將_ name__修改為__main\
頂層代碼: 模塊中縮進最外層的代碼(當前解釋器執行的環境)
如果是import 導入的,其_ name_ 默認就是模塊名創建一個自定義模塊,并獲取其模塊名
目標模塊中導入并打印相關模塊名
4 if name == ' main ': 用途
1 本模塊的功能測試
測試本模塊內的函數,類2 避免主模塊變更的副作用
頂層代碼,沒有封裝,主模塊使用沒有問題,但是,一旦有了新的主模塊,當前模塊要被導入,由于源代碼沒有封裝,則會一并被執行。
5模塊內部其他的屬性
屬性 | 含義 |
---|---|
_ file_ | 字符串,源文件路徑 |
_ cached_ | 字符串,編譯后的字節碼文件路徑 |
_ spec_ | 顯示模塊的規范 |
_ name_ | 模塊名 |
_ package_ | 當模塊是包,同_ name_ ,否則,可以設置為頂級模塊的空字符串 |
四 模塊和包
1 模塊
普通文件天然是一個模塊
創建一個普通文件夾,其是一個模塊,無法在文件夾上寫代碼
添加一個模塊n
此模塊下面必須有一個.py的文件,其調用才有意義
此模塊下創建.py文件為n1.py
導入并查看其類型
2 創建包
其自帶_ init_ .py文件
導入結果對比如下
pycharm 中,創建Directory和創建python package 不同,前者是創建普通的目錄,后者是創建一個帶有_ init_ .py文件目錄,及包
3 子模塊
包目錄下的py文件,子目錄都是其子模塊
三個模塊嵌套,都是package,都寫入print (_ name_ )用于獲取包名稱
在test中導入并查看如下
結論: 使用頻率高文件中,使用頻率多的應該放置在_ init_ .py中,因為模塊在初始化過程中總會加載目錄中的_ init_ .py文件及其中的內容,但其不會執行和導入其他相關子模塊
若目錄對應的_ init_ .py 不存在,則進行下一個對應的模塊,作為一個好習慣是_ init_ .py文件必須有,python2中進行了限制,必須有,而python3中則限制不嚴,但建議必須存在
4 模塊和包的總結:
1 包能夠更好的組織模塊,尤其是大規模代碼很多,可以拆分成很多子模塊,便于使用某些功能就加載相應的子目錄
包目錄中_ init_ .py是包在第一次導入時就執行的,內容可以為空,也可以是用于該包的初始化工作的代碼,最好不要刪除它(低版本不可刪除)
導入子模塊一定會加載父模塊,但導入父模塊一定不會加載子模塊
包之間只能使用.點號作為間隔符,表示模塊及子目錄的層級關系
模塊也是封裝,如同類,函數,不過他能夠封裝變量,類,函數
模塊就是名稱空間,其內部的頂層標識符,都是它的屬性,可以通過_ dict_ 或dir(module)查看
包也是模塊,但模塊不一定是包,包是特殊的模塊,是一種組織方式,它包含__path__屬性
5 絕對導入和相對導入
1 概念
凡是通過sys.path 找到的,都是絕對路徑
絕對導入
在import語句或者from導入模塊,模塊名稱最前面不是以.開頭的
絕對導入總是去搜索模塊搜索路徑中找
相對導入
只能在包內使用,且只能用在from語句中
使用.點號,表示當前目錄內
..表示上一級目錄注意:不要在頂層模塊中使用相對導入 (要參與運行的模塊)
2 導入實戰
在w2層級進行導入其父層級
在頂層目錄中導入子模塊
進行在test模塊中導入并查看
若在此頂層域中使用相對路徑,則不行,因為其無法識別.和..等相關操作
6 訪問控制
1 定義變量
定義__x和_y變量及z變量,并進行導入和訪問處理
2 導入并訪問查看
結論:此處未進行相關的保護操作和換名操作
3 使用from w import * 導入
結論:結果是只導入了公共屬性,私有屬性和保護變量屬性都未曾導入
4 引入__all__模塊
_ all_ 是一個可迭代對象,元素是字符串,每一個元素都是一個模塊內的變量名
導入模塊如下
此處連之前的公共屬性也沒有了,只有對應寫入的__all__的屬性
若指定模塊
普通變量,保護變量,私有變量,特殊變量,都沒有被隱藏,也就是說模塊內部沒有私有變量,在模塊中定義不做特殊處理。
5 locals
其和dir()顯示結果完全相同,但dir是列表,而locals是字典類型
局部作用域,locals和dir都有局部作用域的概念
寫入子模塊導入
導入查看
6 總結:
1 使用from ... import * 導入
A 如果模塊中沒有_ all_ 。from ... import * 只能導入非下劃線開頭的模塊的變量,如果是包,子模塊也不會導入,除非在_ all__中設置,或者在_ init\ .py中使用相對導入
B 如果模塊中有_ all_ ,from ... import * 只導入_ all_ 列表中指定的名稱,哪怕這個名詞是下劃線開頭的,或者是子模塊
C from ... import * 方式導入,使用簡短,其副作用是會導入大量不需要使用的環境變量,甚至造成名稱沖突,而_ all_ 可以控制被導入模塊在這種導入方式下能夠提供的變量名稱,就是為了阻止from ... import *導入過多的模塊變量,從而避免沖突,因此,編寫模塊時,應該盡量加入_ all_
2 from module import name1,name2 導入
這種方式的導入是明確的,哪怕是導入子模塊,或者導入下劃線開頭的名稱,程序員可以有控制和導入名稱和其對應的對象
7 模塊變量的修改
w1 的_ init_ .py中定義一個參數z
在test1 中引入并對其進行修改
在test中進入并進行查看
結論:
模塊對象是同一個,因此模塊的變量也是同一個,對模塊變量的修改,會影響所有使用者,除非萬不得已,或明確知道自己在做什么,否則不要修改模塊的變量
前面已經學習過猴子補丁,也可以通過打補丁的方式,修改模塊的變量,類,函數等內容
五 包管理
1 為什么要使用包管理
python 的模塊或者源文件直接可以復制到項目中,便可以導入使用了,但為了更多項目的調用和使用,或者共享給別人,就需要進行打包,或者發布到網絡上,便于其他人使用。目的是為了復用 。
本地使用的方式:
1 將模塊或包放置到sys.path的搜索路徑中即可
2 將此模塊所在的路徑加入到sys.path中即可,因為其是一個列表
2 主要工具
1 distutils 官方庫distutils,使用安裝腳本setup.py來構建,安裝包
2 setuptools
是替代distutils 的增強版本工具,包括easy_install工具,使用ez_setup.py 文件,支持egg格式的構建和安裝
其能夠提供查詢,下載,安裝,構建,發布,管理包等包管理功能setuptools 不再維護了。distribute是setuptools的替代品,其名字還是setuptools
3 pip
pip 是目前包管理的實施標準,構建在setuptools之上,代替easy_install的同時也提供了豐富的包管理功能,一般的,都會攜帶setuptools和easy_install
4 wheel
提供bdist_wheel作為setuptools的擴展命令,這個命令可以用來生成wheel打包格式,pip 提供了一個wheel子命令來安裝wheel包,當然,需要先安裝wheel模塊,它可以讓python庫以二進制形式安裝,而不需要在本地編譯。
3 使用setup.py 打包
1 包結構如下 :
test 中包含自己的初始化文件_ init_ .py及模塊test1.py 和包test2.py,test2.py中包含自己的初始化文件_ init_ .py和test21.py模塊。
2 創建setup.py文件
其路徑在該包裝的最外層。
內容如下
#!/usr/bin/poython3.6
#conding:utf-8
from distutils.core import setup
setup(
name='test', # 名字
version='0.1.0', #版本
description='Python test', #打包列表
author='zhang', # 作者
author_email='12345678910@163.com', #
# url 表示包幫助文檔路徑
packages=['test'] # 打包列表,指定test,會把w所有的非目錄字母模塊打包
)
3 打包
目錄結構
(zhangbing) [root@python python3.5]# python setup.py build
running build
running build_py
creating build
creating build/lib
creating build/lib/test
copying test/test1.py -> build/lib/test
copying test/__init__.py -> build/lib/test
(zhangbing) [root@python python3.5]# ls
build setup.py test
(zhangbing) [root@python python3.5]# tree build/
build/
└── lib
└── test
├── __init__.py
└── test1.py
2 directories, 2 files
(zhangbing) [root@python python3.5]#
此處只包含了 init .py和test1,而沒有穿透目錄進入test2和test21
修改如下
#!/usr/bin/poython3.6
#conding:utf-8
from distutils.core import setup
setup(
name='test', # 名字
version='0.1.0', #版本
description='Python test', #打包列表
author='zhang', # 作者
author_email='12345678910@163.com', #
# url 表示包幫助文檔路徑
packages=['test.test2'] # 此時只會打印test2中的test21.py和__init__.py
)
刪除原來打包結果 如下
(zhangbing) [root@python python3.5]# rm -rf build/
(zhangbing) [root@python python3.5]# ls
setup.py test
(zhangbing) [root@python python3.5]# python setup.py build
running build
running build_py
creating build
creating build/lib
creating build/lib/test
creating build/lib/test/test2
copying test/test2/test21.py -> build/lib/test/test2
copying test/test2/__init__.py -> build/lib/test/test2
(zhangbing) [root@python python3.5]# tree build/
build/
└── lib
└── test
└── test2
├── __init__.py
└── test21.py
3 directories, 2 files
要使得全部打包,則需要
#!/usr/bin/poython3.6
#conding:utf-8
from distutils.core import setup
setup(
name='test', # 名字
version='0.1.0', #版本
description='Python test', #打包列表
author='zhang', # 作者
author_email='12345678910@163.com', #
# url 表示包幫助文檔路徑
packages=['test','test.test2']
)
刪除上述build,如下
(zhangbing) [root@python python3.5]# rm -rf build/
(zhangbing) [root@python python3.5]# python setup.py build
running build
running build_py
creating build
creating build/lib
creating build/lib/test
copying test/test1.py -> build/lib/test
copying test/__init__.py -> build/lib/test
creating build/lib/test/test2
copying test/test2/test21.py -> build/lib/test/test2
copying test/test2/__init__.py -> build/lib/test/test2
(zhangbing) [root@python python3.5]# tree build/
build/
└── lib
└── test
├── __init__.py
├── test1.py
└── test2
├── __init__.py
└── test21.py
3 directories, 4 files
4 install 安裝命令
build之后就可以install了,直接運行如下
(zhangbing) [root@python python3.5]# python setup.py install
running install
running build
running build_py
running install_lib
creating /root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test
copying build/lib/test/test1.py -> /root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test
copying build/lib/test/__init__.py -> /root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test
creating /root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test2
copying build/lib/test/test2/test21.py -> /root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test2
copying build/lib/test/test2/__init__.py -> /root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test2
byte-compiling /root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test1.py to test1.cpython-36.pyc
byte-compiling /root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/__init__.py to __init__.cpython-36.pyc
byte-compiling /root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test2/test21.py to test21.cpython-36.pyc
byte-compiling /root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test2/__init__.py to __init__.cpython-36.pyc
running install_egg_info
Writing /root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test-0.1.0-py3.6.egg-info
(zhangbing) [root@python python3.5]# ls
build setup.py test
(zhangbing) [root@python python3.5]# tree /root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test
├── __init__.py
├── __pycache__
│?? ├── __init__.cpython-36.pyc
│?? └── test1.cpython-36.pyc
├── test1.py
└── test2
├── __init__.py
├── __pycache__
│?? ├── __init__.cpython-36.pyc
│?? └── test21.cpython-36.pyc
└── test21.py
3 directories, 8 files
其會自動添加到對應的第三方文件夾中,對應的是/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages
4 命令分發
1 sdist命令簡介
創建源代碼的分發包
產生一個dist目錄,里面生成一個帶版本號的壓縮包。
在其他地方解壓這個文件,里面有setup.py,就可以使用python setup.py install 進行安裝了,也可以使用pip install x.zip 直接安裝這個壓縮包
2 打包操作
安裝相關依賴包
yum -y install rpm-build
打包成rpm 如下
(zhangbing) [root@python python3.5]# rm -rf build/ dist/ MANIFEST
(zhangbing) [root@python python3.5]# ls
setup.py test
(zhangbing) [root@python python3.5]# python setup.py bdist_rpm
(zhangbing) [root@python python3.5]# python setup.py bdist_rpm
running bdist_rpm
creating build
creating build/bdist.linux-x86_64
creating build/bdist.linux-x86_64/rpm
creating build/bdist.linux-x86_64/rpm/SOURCES
creating build/bdist.linux-x86_64/rpm/SPECS
creating build/bdist.linux-x86_64/rpm/BUILD
creating build/bdist.linux-x86_64/rpm/RPMS
creating build/bdist.linux-x86_64/rpm/SRPMS
...
+ rm -rf test-0.1.0
+ exit 0
moving build/bdist.linux-x86_64/rpm/SRPMS/test-0.1.0-1.src.rpm -> dist
moving build/bdist.linux-x86_64/rpm/RPMS/noarch/test-0.1.0-1.noarch.rpm -> dist
結果如下
(zhangbing) [root@python python3.5]# ls
build dist MANIFEST setup.py test
(zhangbing) [root@python python3.5]# tree dist/
dist/
├── test-0.1.0-1.noarch.rpm
├── test-0.1.0-1.src.rpm
└── test-0.1.0.tar.gz
0 directories, 3 files
(zhangbing) [root@python python3.5]# tree build/
build/
└── bdist.linux-x86_64
└── rpm
├── BUILD
├── BUILDROOT
├── RPMS
│?? └── noarch
├── SOURCES
│?? └── test-0.1.0.tar.gz
├── SPECS
│?? └── test.spec
└── SRPMS
9 directories, 2 files
此處在dict中生成了rpm包
3 安裝如下
(zhangbing) [root@python dist]# rpm -ivh test-0.1.0-1.noarch.rpm
準備中... ################################# [100%]
正在升級/安裝...
1:test-0.1.0-1 ################################# [100%]
查看如下
(zhangbing) [root@python dist]# rpm -ql test
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test-0.1.0-py3.6.egg-info
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/__init__.py
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/__pycache__/__init__.cpython-36.opt-1.pyc
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/__pycache__/__init__.cpython-36.pyc
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/__pycache__/test1.cpython-36.opt-1.pyc
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/__pycache__/test1.cpython-36.pyc
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test1.py
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test2/__init__.py
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test2/__pycache__/__init__.cpython-36.opt-1.pyc
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test2/__pycache__/__init__.cpython-36.pyc
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test2/__pycache__/test21.cpython-36.opt-1.pyc
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test2/__pycache__/test21.cpython-36.pyc
/root/.pyenv/versions/zhangbing/lib/python3.6/site-packages/test/test2/test21.py
六 插件化開發基本概述
1 概述
動態導入: 運行時根據用戶需求(提供字符串),找到模塊的資源動態加載起來,相較于之前的導入,其import在編譯期就決定的功能,是死的,不好用。
內建函數_ import_ ()
相關參數
_ import_ (name,globals=None,locals=None,fromlist=(),level=0)
name,模塊名,global全局生效,locals局部生效
sys=_ import_ ('sys') 等價于 import sys
2 實例如下
結構如下
代碼如下
#!/usr/bin/poython3.6
#conding:utf-8
# this is test1
class A:
def show(self):
print ('this is test1')
#!/usr/bin/poython3.6
#conding:utf-8
# this is test
print (__import__('test1')) # 此處獲取到一個模塊對象
# 將模塊賦值
mod=__import__('test1') # 給模塊賦值
getattr(mod,'A')().show() # 此處調用模塊中的A類并進行實例化后調用show方法
test結果如下
將此方式移動進入主模塊中如下
#!/usr/bin/poython3.6
#conding:utf-8
# this is test
if __name__ == "__main__":
print(__import__('test1')) # 此處獲取到一個模塊對象
# 將模塊賦值
mod = __import__('test1') # 給模塊賦值
getattr(mod, 'A')().show() # 此處調用模塊中的A類并進行實例化后調用show方法
結果也是相同,但別人在調用此模塊時,其中的內容不會打印
進行函數化操作處理
#!/usr/bin/poython3.6
#conding:utf-8
# this is test
def plugin_load():
mod=__import__('test1')
getattr(mod,'A')().show()
if __name__ == "__main__":
# 在需要時進行動態加載
plugin_load()
上述方式只能每次加載一個,而不能實現多個加載,若想加載多個,則需要使用下面代碼
多個加載
#!/usr/bin/poython3.6
#conding:utf-8
# this is test
def plugin_load(plugin_name:str,seq=":"):
module,_,clas =plugin_name.partition(seq) #通過此處切割將獲取模塊名和對應的內部的類或函數的屬性名
mod=__import__(module)
cls=getattr(mod,clas)().show() # 獲取屬性并進行調用其方法,此處的返回有業務需求決定
return cls
if __name__ == "__main__":
# 在需要時進行動態加載
# 進行調用處理
plugin_load("test1:A")
結果如下
#!/usr/bin/poython3.6
#conding:utf-8
# this is test
def plugin_load(plugin_name:str,seq=":"):
module,_,clas =plugin_name.partition(seq) #通過此處切割將獲取模塊名和對應的內部的類或函數的屬性名
mod=__import__(module)
cls=getattr(mod,clas) # 獲取屬性并進行調用其方法,此處的返回有業務需求決定
return cls() # 此處返回一個實例
if __name__ == "__main__":
# 在需要時進行動態加載
# 進行調用處理
plugin_load("test1:A").show()
結果如下
3 import_module
格式 importlib.import_module(name,package=None)
支持絕對導入和相對導入,如果是相對導入package必須設置
實例如下
#!/usr/bin/poython3.6
#conding:utf-8
# this is test
import importlib
def plugin_load(plugin_name:str,seq=":"):
module,_,clas =plugin_name.partition(seq) #通過此處切割將獲取模塊名和對應的內部的類或函數的屬性名
mod=importlib.import_module(module)
cls=getattr(mod,clas) # 獲取屬性并進行調用其方法,此處的返回有業務需求決定
return cls() # 此處返回一個實例
if __name__ == "__main__":
# 在需要時進行動態加載
# 進行調用處理
plugin_load("test1:A").show()
結果如下
4 插件化編程技術概述
1 依賴技術
反射: 運行時獲取類型的信息,可以動態維護類型數據
動態import: 推薦使用importlib模塊,實現動態import模塊的能力
多線程:可以開啟一個線程,等待用戶輸入,從而加載指定名稱的模塊
2 加載時機
加載的類型
1 程序啟動時加載: 像pycharm這樣的工具,需要很多組件,這些組件可能是插件,啟動的時候掃描固定的目錄加載插件
2 程序運行中: 程序運行過程中,接受用戶指令或請求,啟動相應的插件
優缺點:
兩種方式各有利弊,如果插件很多,會導致程序啟動很慢。如果用戶需要時再加載,如果插件太大或者依賴太多,插件啟動慢。所以必須先加載常用的插件,其他插件使用時,發現需要再插入
3 接口和插件區別
接口往往是暴露出來的功能,如模塊提供的函數或方法,加載模塊后調用這些函數完成功能,接口是一種規范,他約定了必須實現功能,但不關心如何實現此功能
插件是把模塊加載到系統中,運行它,增強當前系統功能,或者提供系統不具備的功能,往往插件技術應用在框架設計中,系統本身設計簡化、輕量級、實現基本功能后,其他功能通過插件加入進來,方便擴展。
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索:z360901061

微信掃一掃加我為好友
QQ號聯系: 360901061
您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點擊下面給點支持吧,站長非常感激您!手機微信長按不能支付解決辦法:請將微信支付二維碼保存到相冊,切換到微信,然后點擊微信右上角掃一掃功能,選擇支付二維碼完成支付。
【本文對您有幫助就好】元
