1.摘要

常用模塊

對象編程

領域模型

2.常用模塊

2.1shutil模塊

2.1.1?shutil.copyfileobj(fsrc, fdst[, length])

1 f = open("test.txt","r",encoding="utf-8")2 f1 = open("test2.txt","w+",encoding="utf-8")3

4 shutil.copyfileobj(f,f1,length=1000) #對文件對象進行拷貝操作，都需要打開后才能操作,length指定緩沖區的大小5 f.close()6 f1.close()

2.1.2?shutil.copyfile(src,dst)

1 shutil.copyfile("test.txt", "test2.txt") #對文件進行操作

2.1.3?shutil.copymode(src,dst)

#僅copy權限，不更改文件內容，組和用戶

2.1.4?shutil.copystat(src, dst)

拷貝狀態的信息，包括：mode bits, atime, mtime, flags

2.1.5shutil.copy(src, dst)

拷貝文件和權限

2.1.6?shutil.copy2(src,dst)

#復制文件的內容以及文件的所有狀態信息。先copyfile后copystat

2.1.7?shutil.ignore_patterns(*patterns)

shutil.copytree(src, dst, symlinks=False, ignore=None)

1 shutil.copytree("E:\Python\mytest\\atm","E:\Python\mytest\\test\mytmp",ignore=shutil.ignore_patterns("atm","*.py"))

2.1.8?shutil.rmtree(path[, ignore_errors[, onerror]])

1 shutil.rmtree("E:\Python\mytest\\test\mytmp") #包括mytmp目錄也會備刪除

2.1.9?shutil.move(src, dst)

#遞歸的移動文件

1 shutil.move("E:\Python\mytest\\test\mytmp1","E:\Python\mytest\\test\mytmp") #將包括mytmp1目錄全部移動至mytmp目錄

2.1.10?shutil.make_archive(base_name, format,...)

1 shutil.make_archive("E:\Python\mytest\\test\\test","zip",root_dir="E:\Python\mytest\\atm") #壓縮單個目錄

2.2zipfile和tarfile模塊

1 import zipfile2

3 z = zipfile.ZipFile("mytest.zip","w")4 z.write("E:\Python\mytest\\atm\\atm\\bin\\atm.py")5 z.write("E:\Python\mytest\\atm\\atm\core\main.py")6 z.close()7

8 #壓縮文件包含原有文件路徑目錄

1 import zipfile2

3 z = zipfile.ZipFile("mytest.zip","w")4 z.write("E:\Python\mytest\\atm\\atm\\bin\\atm.py",arcname="atm.py")5 z.write("E:\Python\mytest\\atm\\atm\core\main.py",arcname="main.py")6 z.close()7

8 #壓縮文件不包含原有文件路徑目錄

2.3 shelve模塊

shelve模塊是一個簡單的k,v將內存數據通過文件持久化的模塊，可以持久化任何pickle可支持的python數據格式

1 importshelve2

3 d = shelve.open('shelve_test') #打開一個文件

4

5 classTest(object):6 def __init__(self,n):7 self.n =n8

9

10 t = Test(123)11 t2 = Test(123334)12

13 name = ["alex","rain","test"]14 d["test"] = name #持久化列表

15 d["t1"] = t #持久化類

16 d["t2"] =t217

18 d.close()

2.4 xml模塊

xml是實現不同語言或程序之間進行數據交換的協議，跟json差不多，但json使用起來更簡單，不過，古時候，在json還沒誕生的黑暗年代，大家只能選擇用xml呀，至今很多傳統公司如金融行業的很多系統的接口還主要是xml。

xml的格式如下，就是通過<>節點來區別數據結構的:

2

2008

141100

5

2011

59900

69

2011

13600

xml樣例

2.4.1查詢

1 mport xml.etree.ElementTree as ET2

3 tree = ET.parse("xmltest.xml")4 root =tree.getroot()5 print(root.tag)6

7 #遍歷xml文檔

8 for child inroot:9 print(child.tag, child.attrib)10 for i inchild:11 print(i.tag,i.text)12

13 #只遍歷year 節點

14 for node in root.iter('year'):15 print(node.tag,node.text)

2.4.2修改和刪除

1 importxml.etree.ElementTree as ET2

3 tree = ET.parse("xmltest.xml")4 root =tree.getroot()5

6 #修改

7 for node in root.iter('year'):8 new_year = int(node.text) + 1

9 node.text =str(new_year)10 node.set("updated","yes")11

12 tree.write("xmltest.xml")13

14

15 #刪除node

16 for country in root.findall('country'):17 rank = int(country.find('rank').text)18 if rank > 50:19 root.remove(country)20

21 tree.write('output.xml')

2.4.3 創建xml

1 importxml.etree.ElementTree as ET2

3

4 new_xml = ET.Element("namelist")5 name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})6 age = ET.SubElement(name,"age",attrib={"checked":"no"})7 sex = ET.SubElement(name,"sex")8 sex.text = '33'

9 name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})10 age = ET.SubElement(name2,"age")11 age.text = '19'

12

13 et = ET.ElementTree(new_xml) #生成文檔對象

14 et.write("test.xml", encoding="utf-8",xml_declaration=True)15

16 ET.dump(new_xml) #打印生成的格式

2.5 PyYAML模塊

Python也可以很容易的處理ymal文檔格式，只不過需要安裝一個模塊，參考文檔：http://pyyaml.org/wiki/PyYAMLDocumentation

2.6 ConfigParse模塊

[DEFAULT]

ServerAliveInterval= 45Compression=yes

CompressionLevel= 9ForwardX11=yes

[bitbucket.org]

User=hg

[topsecret.server.com]

Port= 50022ForwardX11= no

配置文件樣例

2.6.1創建配置文件

1 importconfigparser2

3 config =configparser.ConfigParser()4 config["DEFAULT"] = {'ServerAliveInterval': '45',5 'Compression': 'yes',6 'CompressionLevel': '9'}7

8 config['bitbucket.org'] ={}9 config['bitbucket.org']['User'] = 'hg'

10 config['topsecret.server.com'] ={}11 topsecret = config['topsecret.server.com']12 topsecret['Host Port'] = '50022' #mutates the parser

13 topsecret['ForwardX11'] = 'no' #same here

14 config['DEFAULT']['ForwardX11'] = 'yes'

15 with open('example.ini', 'w') as configfile:16 config.write(configfile)

2.6.2 查詢

1 >>> importconfigparser2 >>> config =configparser.ConfigParser()3 >>>config.sections()4 []5 >>> config.read('example.ini')6 ['example.ini']7 >>>config.sections()8 ['bitbucket.org', 'topsecret.server.com']9 >>> 'bitbucket.org' inconfig10 True11 >>> 'bytebong.com' inconfig12 False13 >>> config['bitbucket.org']['User']14 'hg'

15 >>> config['DEFAULT']['Compression']16 'yes'

17 >>> topsecret = config['topsecret.server.com']18 >>> topsecret['ForwardX11']19 'no'

20 >>> topsecret['Port']21 '50022'

22 >>> for key in config['bitbucket.org']: print(key)23 ...24 user25 compressionlevel26 serveraliveinterval27 compression28 forwardx1129 >>> config['bitbucket.org']['ForwardX11']30 'yes'

2.6.3 配置文件增刪改查

1 importconfigparser2

3 config =configparser.ConfigParser()4 config.read("example.ini")5

6 print(config.sections())7 ['bitbucket.org', 'topsecret.server.com']8 DEFAULT默認存在9

10 print(config.options("topsecret.server.com"))11 ['host port', 'forwardx11', 'compression', 'compressionlevel', 'serveraliveinterval']12

13 print(config.items("topsecret.server.com"))14 [('compression', 'yes'), ('compressionlevel', '9'), ('serveraliveinterval', '45'), ('forwardx11', 'no'), ('host port', '50022')]15

16 config.remove_section("bitbucket.org") #刪除一個section

17 config.write(open("test.ini","w"))18

19 config.add_section("test") #添加一個section

20 config.set("test","k1","11111") #修改option的值

21 config.write(open('test2.ini', "w"))

2.7 hashlib模塊

用于加密相關的操作，3.x里代替了md5模塊和sha模塊，主要提供?SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

1 importhashlib2

3 m =hashlib.md5()4 m.update(b"Hello")5 m.update(b"It's me")6 print(m.digest())7 m.update(b"It's been a long time since last time we ...")8

9 print(m.digest()) #2進制格式hash

10 print(len(m.hexdigest())) #16進制格式hash

11 '''

12 def digest(self, *args, **kwargs): # real signature unknown13 """ Return the digest value as a string of binary data. """14 pass15

16 def hexdigest(self, *args, **kwargs): # real signature unknown17 """ Return the digest value as a string of hexadecimal digits. """18 pass19

20 '''

21 importhashlib22

23 ######### md5 ########

24

25 hash =hashlib.md5()26 hash.update('admin')27 print(hash.hexdigest())28

29 ######### sha1 ########

30

31 hash =hashlib.sha1()32 hash.update('admin')33 print(hash.hexdigest())34

35 ######### sha256 ########

36

37 hash =hashlib.sha256()38 hash.update('admin')39 print(hash.hexdigest())40

41

42 ######### sha384 ########

43

44 hash =hashlib.sha384()45 hash.update('admin')46 print(hash.hexdigest())47

48 ######### sha512 ########

49

50 hash =hashlib.sha512()51 hash.update('admin')52 print(hash.hexdigest())

python 還有一個 hmac 模塊，它內部對我們創建 key 和 內容 再進行處理然后再加密

散列消息鑒別碼，簡稱HMAC，是一種基于消息鑒別碼MAC(Message Authentication Code)的鑒別機制。使用HMAC時,消息通訊的雙方，通過驗證消息中加入的鑒別密鑰K來鑒別消息的真偽；

一般用于網絡通信中消息加密，前提是雙方先要約定好key,就像接頭暗號一樣，然后消息發送把用key把消息加密，接收方用key ＋ 消息明文再加密，拿加密后的值 跟 發送者的相對比是否相等，這樣就能驗證消息的真實性，及發送者的合法性了。

1 importhmac2 h = hmac.new(b'天王蓋地虎', b'寶塔鎮河妖')3 print h.hexdigest()

更多關于md5,sha1,sha256等介紹的文章看這里https://www.tbs-certificates.co.uk/FAQ/en/sha256.html

2.8 subprocess模塊

1 #執行命令，返回命令執行狀態 ， 0 or 非0

2 >>> retcode = subprocess.call(["ls", "-l"])3

4 #執行命令，如果命令結果為0，就正常返回，否則拋異常

5 >>> subprocess.check_call(["ls", "-l"])6 07

8 #接收字符串格式命令，返回元組形式，第1個元素是執行狀態，第2個是命令結果

9 >>> subprocess.getstatusoutput('ls /bin/ls')10 (0, '/bin/ls')11

12 #接收字符串格式命令，并返回結果

13 >>> subprocess.getoutput('ls /bin/ls')14 '/bin/ls'

15

16 #執行命令，并返回結果，注意是返回結果，不是打印，下例結果返回給res

17 >>> res=subprocess.check_output(['ls','-l'])18 >>>res19 b'total 0\ndrwxr-xr-x 12 alex staff 408 Nov 2 11:05 OldBoyCRM\n'

20

21 #上面那些方法，底層都是封裝的subprocess.Popen

22 poll()23 Check ifchild process has terminated. Returns returncode24

25 wait()26 Wait forchild process to terminate. Returns returncode attribute.27

28

29 terminate() 殺掉所啟動進程30 communicate() 等待任務結束31

32 stdin 標準輸入33

34 stdout 標準輸出35

36 stderr 標準錯誤37

38 pid39 The process ID of the child process.40

41 #例子

42 >>> p = subprocess.Popen("df -h|grep disk",stdin=subprocess.PIPE,stdout=subprocess.PIPE,shell=True)43 >>>p.stdout.read()44 b'/dev/disk1 465Gi 64Gi 400Gi 14% 16901472 104938142 14% /\n'

調用subprocess.run(...)是推薦的常用方法，在大多數情況下能滿足需求，但如果你可能需要進行一些復雜的與系統的交互的話，你還可以用subprocess.Popen(),語法如下：

1 p = subprocess.Popen("find / -size +1000000 -exec ls -shl {} \;",shell=True,stdout=subprocess.PIPE)2 print(p.stdout.read())

可用參數：

args：shell命令，可以是字符串或者序列類型(如：list，元組)

bufsize：指定緩沖。0 無緩沖,1 行緩沖,其他 緩沖區大小,負值 系統緩沖

stdin, stdout, stderr：分別表示程序的標準輸入、輸出、錯誤句柄

preexec_fn：只在Unix平臺下有效，用于指定一個可執行對象(callable object)，它將在子進程運行之前被調用

close_sfs：在windows平臺下，如果close_fds被設置為True，則新創建的子進程將不會繼承父進程的輸入、輸出、錯誤管道。

所以不能將close_fds設置為True同時重定向子進程的標準輸入、輸出與錯誤(stdin, stdout, stderr)。

shell：同上

cwd：用于設置子進程的當前目錄

env：用于指定子進程的環境變量。如果env = None，子進程的環境變量將從父進程中繼承。

universal_newlines：不同系統的換行符不同，True -> 同意使用 \n

startupinfo與createionflags只在windows下有效

將被傳遞給底層的CreateProcess()函數，用于設置子進程的一些屬性，如：主窗口的外觀，進程的優先級等等

終端輸入的命令分為兩種：

輸入即可得到輸出，如：ifconfig

輸入進行某環境，依賴再輸入，如：python

2.9 re模塊

3.對象編程

3.1面向過程和面向對象

編程范式

編程是 程序 員 用特定的語法+數據結構+算法組成的代碼來告訴計算機如何執行任務的過程 ， 一個程序是程序員為了得到一個任務結果而編寫的一組指令的集合，正所謂條條大路通羅馬，實現一個任務的方式有很多種不同的方式， 對這些不同的編程方式的特點進行歸納總結得出來的編程方式類別，即為編程范式。 不同的編程范式本質上代表對各種類型的任務采取的不同的解決問題的思路， 大多數語言只支持一種編程范式，當然也有些語言可以同時支持多種編程范式。 兩種最重要的編程范式分別是面向過程編程和面向對象編程。

面向過程編程(Procedural Programming)

Procedural programming uses a list of instructions to tell the computer what to do step-by-step.

面向過程編程依賴 - 你猜到了- procedures，一個procedure包含一組要被進行計算的步驟， 面向過程又被稱為top-down languages， 就是程序從上到下一步步執行，一步步從上到下，從頭到尾的解決問題 。基本設計思路就是程序一開始是要著手解決一個大的問題，然后把一個大問題分解成很多個小問題或子過程，這些子過程再執行的過程再繼續分解直到小問題足夠簡單到可以在一個小步驟范圍內解決。

面向對象編程

OOP編程是利用“類”和“對象”來創建各種模型來實現對真實世界的描述，使用面向對象編程的原因一方面是因為它可以使程序的維護和擴展變得更簡單，并且可以大大提高程序開發效率 ，另外，基于面向對象的程序可以使它人更加容易理解你的代碼邏輯，從而使團隊開發變得更從容。

面向對象的幾個核心特性如下

Class 類

一個類即是對一類擁有相同屬性的對象的抽象、藍圖、原型。在類中定義了這些對象的都具備的屬性(variables(data))、共同的方法

Object 對象

一個對象即是一個類的實例化后實例，一個類必須經過實例化后方可在程序中調用，一個類可以實例化多個對象，每個對象亦可以有不同的屬性，就像人類是指所有人，每個人是指具體的對象，人與人之前有共性，亦有不同

Encapsulation 封裝

在類中對數據的賦值、內部調用對外部用戶是透明的，這使類變成了一個膠囊或容器，里面包含著類的數據和方法

Inheritance 繼承

一個類可以派生出子類，在這個父類里定義的屬性、方法自動被子類繼承

Polymorphism 多態

多態是面向對象的重要特性,簡單點說:“一個接口，多種實現”，指一個基類中派生出了不同的子類，且每個子類在繼承了同樣的方法名的同時又對父類的方法做了不同的實現，這就是同一種事物表現出的多種形態。

編程其實就是一個將具體世界進行抽象化的過程，多態就是抽象化的一種體現，把一系列具體事物的共同點抽象出來, 再通過這個抽象的事物, 與不同的具體事物進行對話。

對不同類的對象發出相同的消息將會有不同的行為。比如，你的老板讓所有員工在九點鐘開始工作, 他只要在九點鐘的時候說：“開始工作”即可，而不需要對銷售人員說：“開始銷售工作”，對技術人員說：“開始技術工作”, 因為“員工”是一個抽象的事物, 只要是員工就可以開始工作，他知道這一點就行了。至于每個員工，當然會各司其職，做各自的工作。

多態允許將子類的對象當作父類的對象使用，某父類型的引用指向其子類型的對象,調用的方法是該子類型的方法。這里引用和調用方法的代碼編譯前就已經決定了,而引用所指向的對象可以在運行期間動態綁定

3.2面向對象編程

對于編程語言的初學者來講，OOP不是一個很容易理解的編程方式，大家雖然都按老師講的都知道OOP的三大特性是繼承、封裝、多態，并且大家也都知道了如何定義類、方法等面向對象的常用語法，但是一到真正寫程序的時候，還是很多人喜歡用函數式編程來寫代碼，特別是初學者，很容易陷入一個窘境就是“我知道面向對象，我也會寫類，但我依然沒發現在使用了面向對象后，對我們的程序開發效率或其它方面帶來什么好處，因為我使用函數編程就可以減少重復代碼并做到程序可擴展了，為啥子還用面向對象？”。 對于此，我個人覺得原因應該還是因為你沒有充分了解到面向對象能帶來的好處，今天我就寫一篇關于面向對象的入門文章，希望能幫大家更好的理解和使用面向對象編程。

無論用什么形式來編程，我們都要明確記住以下原則：

寫重復代碼是非常不好的低級行為

你寫的代碼需要經常變更

開發正規的程序跟那種寫個運行一次就扔了的小腳本一個很大不同就是，你的代碼總是需要不斷的更改，不是修改bug就是添加新功能等，所以為了日后方便程序的修改及擴展，你寫的代碼一定要遵循易讀、易改的原則(專業數據叫可讀性好、易擴展)。

3.3 面向對象的特性

封裝

繼承

多態

4.領域模型

領域模型,顧名思義,就是需求所涉及的領域的一個建模,更通俗的講法是業務模型。 參考百度百科(http://baike.baidu.cn/view/757895.htm?),領域模型定義如下:

從這個定義我們可以看出,領域模型有兩個主要的作用:

發掘重要的業務領域概念

建立業務領域概念之間的關系

領域建模三字經

領域模型如此重要,很多同學可能會認為領域建模很復雜,需要很高的技巧。然而事實上領域建模非常簡 單,簡單得有點難以讓人相信,領域建模的方法概括一下就是“找名詞”! 許多同學看到這個方法后估計都會笑出來:太假了吧,這么簡單,找個初中生都會啊,那我們公司那些分 析師和設計師還有什么用哦?

分析師和設計師當然有用,后面我們會看到,即使是簡單的找名詞這樣的操作,也涉及到分析和提煉,而 不是簡單的摘取出來就可,這種情況下分析師和設計師的經驗和技能就能夠派上用場了。但領域模型分析 也確實相對簡單,即使沒有豐富的經驗和高超的技巧,至少也能完成一個能用的領域模型。

雖然我們說“找名詞”很簡單,但一個關鍵的問題還沒有說明:從哪里找? 如果你還記得領域模型是“需求到面向對象的橋梁”,那么你肯定一下子就能想到:從需求模型中找,具 體來說就是從用例中找。

歸納一下域建模的方法就是“從用例中找名詞”。 當然,找到名詞后,為了能夠更加符合面向對象的要求和特點,我們還需要對這些名詞進一步完善,這就 是接下來的步驟:加屬性,連關系!

最后我們總結出領域建模的三字經方法:找名詞、加屬性、連關系。

總結

以上是生活随笔為你收集整理的python最常用的编程方式是什么_python常用模块和对象编程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。