python-模塊系列

時間 2020-06-22

標籤 python 模塊系列欄目 Python 简体版

原文原文鏈接

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

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

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

模塊分爲三種：linux

自定義模塊
第三方模塊
內置模塊

自定義模塊

自定義模塊很好理解了，就是本身寫的模塊，它能夠是一個.py的文件，也能夠是一個文件夾（若是是文件夾必須有__int__的目錄纔是模塊，不然就是一個普通目錄）程序員

1.定義模塊

day12就是一個模塊，由於存在__init__.py,day7就不是一個模塊，由於沒有__init__.py文件算法

必定有人會在內心問__init__.py裏面是啥，爲啥就這麼吊，有它就是模塊，沒它就不是模塊shell

最終結果卻使人大失所望，__init__.py裏面啥都木有，說白了就是一個空文件，可是你沒有它就不行，就不是模塊而是文件夾，若是你建了一個文件夾，又想變成模塊，你本身在裏面建立一個__init__.py就好了。編程

2.導入模塊

Python之因此應用愈來愈普遍，在必定程度上也依賴於其爲程序員提供了大量的模塊以供使用，若是想要使用模塊，則須要導入。導入模塊有一下幾種方法：json

1 import module
2 from module.xx.xx import xx
3 from module.xx.xx import xx as rename 
4 from module.xx.xx import *

導入模塊其實就是告訴Python解釋器去解釋那個py文件bash

導入一個py文件，解釋器解釋該py文件
導入一個包，解釋器解釋該包下的 __init__.py 文件【py2.7】

那麼問題來了，導入模塊時是根據那個路徑做爲基準來進行的呢？即：sys.path

import sys
print sys.path

結果：
['', '/usr/lib64/python26.zip', '/usr/lib64/python2.6', '/usr/lib64/python2.6/plat-linux2', '/usr/lib64/python2.6/lib-tk', '/usr/lib64/python2.6/lib-old', '/usr/lib64/python2.6/lib-dynload', '/usr/lib64/python2.6/site-packages', '/usr/lib/python2.6/site-packages', '/usr/lib/python2.6/site-packages/setuptools-0.6c11-py2.6.egg-info']

若是sys.path路徑列表沒有你想要的路徑，能夠經過 sys.path.append('路徑') 添加。

1 import sys
2 import os
3 project_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
4 sys.path.append(project_path)

內置模塊

內置模塊說白了就是python系統自帶的一些經常使用模塊，將一些經常使用的模塊封裝到了裏面，在你使用的時候不用去安裝，直接去引用就能夠了。

1.sys模塊

用於提供對Python解釋器相關的操做：

1 sys.argv           命令行參數List，第一個元素是程序自己路徑
2 sys.exit(n)        退出程序，正常退出時exit(0)
3 sys.version        獲取Python解釋程序的版本信息
4 sys.maxint         最大的Int值
5 sys.path           返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
6 sys.platform       返回操做系統平臺名稱
7 sys.stdin          輸入相關
8 sys.stdout         輸出相關
9 sys.stderror       錯誤相關

實例展現：

 1 sys.argv #命令行參數List，第一個元素是程序自己路徑
 2 print sys.argv
 4 python /root/test.py 123
 5 返回結果：['/root/test.py', '123']
 6 
 7 sys.exit(n)        #退出程序，正常退出時exit(0)
 8 
 9 sys.version         #獲取Python解釋程序的版本信息
10 返回結果：
11 2.6.6 (r266:84292, Nov 22 2013, 12:16:22) 
12 [GCC 4.4.7 20120313 (Red Hat 4.4.7-4)]
13 
15 sys.path    #返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
16 返回結果：
17 ['', '/usr/lib64/python26.zip', '/usr/lib64/python2.6', '/usr/lib64/python2.6/plat-linux2', '/usr/lib64/python2.6/lib-tk', '/usr/lib64/python2.6/lib-old', '/usr/lib64/python2.6/lib-dynload', '/usr/lib64/python2.6/site-packages', '/usr/lib/python2.6/site-packages', '/usr/lib/python2.6/site-packages/setuptools-0.6c11-py2.6.egg-info']
18 
19 sys.platform    #返回操做系統名稱
20 返回結果：
21 'linux2'
22 
23 sys.builtin_module_names #列表包含 Python 解釋器中全部內建模塊的名稱
24 返回結果：
25 ('__builtin__', '__main__', '_ast', '_codecs', '_sre', '_symtable', '_warnings', 'errno', 'exceptions', 'gc', 'imp', 'marshal', 'posix', 'pwd', 'signal', 'sys', 'thread', 'zipimport')
26 
27 sys.modules #字典包含全部加載的模塊. import 語句在從磁盤導入內容以前會先檢查這個字典.
28 返回結果：
29 {'abrt_exception_handler': <module 'abrt_exception_handler' from '/usr/lib64/python2.6/site-packages/abrt_exception_handler.pyc'>, 'os': <module 'os' from '/usr/lib64/python2.6/os.pyc'>}

標準輸出和標準錯誤 (一般縮寫爲 stdout 和 stderr) 是內建在每個 UNIX 系統中的管道。
當你 print 某些東西時，結果前往 stdout 管道；
當你的程序崩潰並打印出調試信息 (例如 Python 中的 traceback (錯誤跟蹤)) 的時候，信息前往 stderr 管道

 1 sys.stdout         #輸出相關
 2 for i in range(3):
 3     print'Dive in'
 4     
 5 Dive in
 6 Dive in
 7 Dive in
 8 import sys
 9 for i in range(3):
10     sys.stdout.write('Dive in')
11 
12 Dive inDive inDive in
13 for i in range(3):
14     sys.stderr.write('Dive in')
15 
16 Dive inDive inDive in
17     sys.stderror #錯誤相關

stdout 是一個類文件對象；調用它的 write 函數能夠打印出你給定的任何字符串。

實際上，這就是 print 函數真正作的事情；它在你打印的字符串後面加上一個硬回車，而後調用 sys.stdout.write 函數。

在最簡單的例子中，stdout 和 stderr 把它們的輸出發送到相同的地方

和 stdout 同樣，stderr 並不爲你添加硬回車；若是須要，要本身加上。

stdout 和 stderr 都是類文件對象，可是它們都是隻寫的。

它們都沒有 read 方法，只有 write 方法。然而，它們仍然是類文件對象，所以你能夠將其它任何 (類) 文件對象賦值給它們來重定向其輸出。

重定向展現

 1 #!/usr/bin/env python
 2 #-*-coding:utf-8-*-
 3 
 4 import sys
 5 
 6 print 'Dive in'        # 標準輸出，輸出到終端上
 7 saveout = sys.stdout        # 終在重定向前保存stdout，這樣的話以後你還能夠將其設回正常
 8 fsock = open('/root/out.log', 'w')      # 打開一個新文件用於寫入。若是文件不存在，將會被建立。若是文件存在，將被覆蓋。
 9 sys.stdout = fsock                 # 全部後續的輸出都會被重定向到剛纔打開的新文件上。
10 
11 print  'This message will be logged instead of displayed'    # 這樣只會將輸出結果「打印」到日誌文件中；屏幕上不會看到輸出
12 
13 sys.stdout = saveout   # 在咱們將 stdout 搞亂以前，讓咱們把它設回原來的方式。    
14 print 'dsadasdadadasdadasda' # 標準輸出，輸出到終端上
15 fsock.close()     # 關閉日誌文件。

結果展現：

這就是 print 函數真正作的事情；它在你打印的字符串後面加上一個硬回車，而後調用 sys.stdout.write 函數

sys.stdin實例：

1 import sys
2 
3 while True:
4     print '請輸入兩個數字，中間用空格隔開'
5     line = sys.stdin.readline()
6     if not line:
7         break
8     a = line.split()
9     print int(a[0]) + int(a[1])

關於raw_put()和readline()的區別：解析文章：http://www.cnblogs.com/dolphin0520/archive/2013/03/27/2985492.html

sys.stdin.readline( )會將標準輸入所有獲取，包括末尾的'\n'，可是raw_input( )獲取輸入時返回的結果是不包含末尾的換行符'\n'的。

小實例：模擬進度條：

#!/usr/bin/env python
# _*_ coding:utf-8 _*_
import sys
for i in range(101):
   #顯示進度條百分比  #號從1開始 空格從99遞減
   hashes = '#' * int(i / 100.0 * 100)
   sys.stdout.write("\r%s %s%%" % (hashes, i))  #必須兩個%%纔是，由於一個%是取模，python解釋器會默認過濾
   sys.stdout.flush() #強制刷新屏幕緩衝區使其一行輸出
   time.sleep(0.5)

2.os模塊

用於提供系統級別的方案

 1 os.getcwd() 獲取當前工做目錄，即當前python腳本工做的目錄路徑
 2 os.chdir("dirname")  改變當前腳本工做目錄；至關於shell下cd
 3 os.curdir  返回當前目錄: ('.')
 4 os.pardir  獲取當前目錄的父目錄字符串名：('..')
 5 os.makedirs('dirname1/dirname2')    可生成多層遞歸目錄
 6 os.removedirs('dirname1')    若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
 7 os.mkdir('dirname')    生成單級目錄；至關於shell中mkdir dirname
 8 os.rmdir('dirname')    刪除單級空目錄，若目錄不爲空則沒法刪除，報錯；至關於shell中rmdir dirname
 9 os.listdir('dirname')    列出指定目錄下的全部文件和子目錄，包括隱藏文件，並以列表方式打印
10 os.remove()  刪除一個文件
11 os.rename("oldname","newname")  重命名文件/目錄
12 os.stat('path/filename')  獲取文件/目錄信息
13 os.sep    輸出操做系統特定的路徑分隔符，win下爲"\\",http://edu.51cto.com/index.php?do=lesson&id=103882Linux下爲"/"
14 os.linesep    輸出當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
15 os.pathsep    輸出用於分割文件路徑的字符串
16 os.name    輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'
17 os.system("bash command")  運行shell命令，直接顯示
18 os.environ  獲取系統環境變量
19 os.path.abspath(path)  返回path規範化的絕對路徑
20 os.path.split(path)  將path分割成目錄和文件名二元組返回
21 os.path.dirname(path)  返回path的目錄。其實就是os.path.split(path)的第一個元素
22 os.path.basename(path)  返回path最後的文件名。如何path以／或\結尾，那麼就會返回空值。即os.path.split(path)的第二個元素
23 os.path.exists(path)  若是path存在，返回True；若是path不存在，返回False
24 os.path.isabs(path)  若是path是絕對路徑，返回True
25 os.path.isfile(path)  若是path是一個存在的文件，返回True。不然返回False
26 os.path.isdir(path)  若是path是一個存在的目錄，則返回True。不然返回False
27 os.path.join(path1[, path2[, ...]])  將多個路徑組合後返回，第一個絕對路徑以前的參數將被忽略
28 os.path.getatime(path)  返回path所指向的文件或者目錄的最後存取時間
29 os.path.getmtime(path)  返回path所指向的文件或者目錄的最後修改時間

3.hashlib

用於加密相關的操做，代替了md5模塊和sha模塊，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

最經常使用的md5方法：

1 import hashlib
2 
3 hash = hashlib.md5() #以md5方式加密
4 hash.update('abcd') #更新哈希對象，以字符串
5 print hash.hexdigest()#返回十六進制數字字符串e2fc714c4727ee9395f324cd2e7f331f
6 print hash.digest() #返回摘要，做爲二進制數據字符串值

查看支持的加密算法：

1 print hashlib.algorithms     #列出全部加密算法
2 #('md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512')

各類加密實例展現：

 1 import hashlib
 2 
 3 # ######## md5 ########
 4 hash = hashlib.md5() #以md5的方式加密
 5 hash.update('admin')
 6 print hash.hexdigest()
 7 print hash.digest()
 8 
 9 ######## sha1 ########
10 
11 hash = hashlib.sha1()#以sha1的方式加密
12 hash.update('admin')
13 print hash.hexdigest()
14 
15 # ######## sha256 ########
16 
17 hash = hashlib.sha256() #以sha256的方式加密
18 hash.update('admin')
19 print hash.hexdigest()
20 
21 
22 # ######## sha384 ########
23 
24 hash = hashlib.sha384() #以sha384的方式加密
25 hash.update('admin')
26 print hash.hexdigest()
27 
28 # ######## sha512 ########
29 
30 hash = hashlib.sha512() #以sha512的方式加密
31 hash.update('admin')
32 print hash.hexdigest()

這麼多方式，能不能把加密方式當參數傳入啊，python固然能夠啦，人生苦短我用python啊！

 1 new(name, string='') #用new 方法，name是指定的加密方式，string是加密的字符串，這地方能夠和update一塊兒用，組成加鹽方式加密
 2      """
 3      Return a new hashing object using the named algorithm;
 4      optionally initialized with a string.
 5      """
 6 import hashlib
 7 #這兩個方式實際上是同樣，可是用new方法更靈活，能夠傳如加密方式
 8 h = hashlib.new('md5')
 9 print h     
10 h.update('beginman')
11 print h.hexdigest() #666fc5baa93a7fb207c5bfff03b67732
12 
13 s = hashlib.md5()
14 s.update('beginman')
15 print s.hexdigest() #666fc5baa93a7fb207c5bfff03b67732

以上加密算法雖然依然很是厲害，但時候存在缺陷，即：經過撞庫能夠反解。因此，有必要對加密算法中添加自定義key再來作加密。

1 hash = hashlib.md5('wolegequ')#這個地方的是你本身在程序裏面加的，不要輕易告訴別人，這樣至關於本身又加了遇到防線。
2 hash.update('zhemediao')
3 print hash.hexdigest()
#d38300d8efb8f70d5828487ff7ca917

還有厲害的加密方法：python 還有一個 hmac 模塊，它內部對咱們建立 key 和內容再進行處理而後再加密。

import hmac
h = hmac.new('wolegequ')
h.update('zhemediao')
print h.hexdigest()
#31f4ff4c716b9bc8d12009fc336c5fd2

增量更新文件太大的時候，能夠分屢次讀入：就是將加密的字符串割成小字符串。

 1 import hashlib
 2 hash = hashlib.md5('wolegequ')
 3 hash.update('zhemediao')#能夠切割成多個使用update方法
 4 hash.update('bixude')#
 5 print hash.hexdigest()
 6 #6cf2ea119f173704dea8860281df3313
 7 
 8 #這個方法和一次更新的結果同樣
 9 hash1 = hashlib.md5('wolegequ')
10 hash1.update('zhemediaobixude')#一整次更新
11 print hash1.hexdigest()
12 #6cf2ea119f173704dea8860281df3313

屬性hashlib.algorithms包含支持的算法。

屬性hash.digest_size ：結果hash的大小

屬性hash. block_size ： hash內部塊的大小

 1 #!/usr/bin/env python
 2 #-*- coding:utf-8 -*-
 3 __author__ = 'wyf'
 4 
 5 import hashlib
 6 
 7 def md5(passwd):
 8     hash = hashlib.md5('admin')
 9     hash.update(passwd)
10     return hash.hexdigest()
11 
12 def registered (user,passwd):#註冊用戶函數
13     with open('db.conf','a') as f:
14         temp = user +'|'+ md5(passwd)
15         f.write(temp+'\n')
16 
17 def login(user,passwd):
18     with open('db.conf','r') as f1:
19         for i in f1:
20             u,p = i.strip().split('|')
21             if u == user and p == md5(passwd):
22                 return  True
23 def main():
24     print u'一、登陸；二、註冊；3.退出'
25     chooseNum = raw_input('請輸入選擇的操做》》》:')
26     if chooseNum == '1':
27         user = raw_input('請輸入用戶名》》》:')
28         passwd = raw_input('請輸入密碼》》》:')
29         if login(user,passwd):
30             print '登陸成功'
31         else:
32             print '登陸失敗'
33 
34     elif chooseNum =='2':
35         user = raw_input('請輸入用戶名》》》:')
36         passwd = raw_input('請輸入密碼》》》:')
37         registered(user,passwd)
38 
39 
40 if __name__ == '__main__':
41     main()

登陸小練習

4.json和pickle

用於序列化的兩個模塊

pickle，用戶python特有的類型和python的數據類型間進行轉換。
json，用於字符串和python的數據類型間進行轉換。

pickle模塊：

pickle模塊使用的數據格式是python專用的，而且不一樣版本不向後兼容，同時也不能被其餘語言識別。要和其餘語言交互，可使用內置的json包，使用pickle模塊你能夠把python對象直接保存到文件，而不須要把他們轉化爲字符串，也不用底層的文件訪問操做把它們寫入到一個二進制文件裏。 pickle模塊會建立一個python語言專用的二進制格式，你基本上不用考慮任何文件細節，它會幫你乾淨利落地完成讀寫獨享操做，惟一須要的只是一個合法的文件句柄。

pickle模塊中的兩個主要函數是dump()和load()。dump()函數接受一個文件句柄和一個數據對象做爲參數，把數據對象以特定的格式保存到給定的文件中。當咱們使用load()函數從文件中取出已保存的對象時，pickle知道如何恢復這些對象到它們原本的格式。
dumps()函數執行和dump() 函數相同的序列化。取代接受流對象並將序列化後的數據保存到磁盤文件，這個函數簡單的返回序列化的數據。
loads()函數執行和load() 函數同樣的反序列化。取代接受一個流對象並去文件讀取序列化後的數據，它接受包含序列化後的數據的str對象, 直接返回的對象。

dumps和dump區別展現：

#!/usr/bin/env python
#-*- coding:utf-8 -*-
import pickle

s = '{"desc":"ininia","status":200,"aaa":[11,22,33,44,55,66]}'

f = open('abc.txt','r+') 
a = pickle.dump(s,f) #dump除了傳存儲對象還有 打開的文件句柄
f.close()

f1 = open('abc1.txt','r+')
a1 = pickle.dumps(s) # dumps 直接傳存儲對象
f.write(a1)
f.close()

loads和load是dumps和dump的反操做所以都同樣。

json模塊：

彷佛pickle已經和吊了，能知足幾乎全部的序列化和反序列話，可是不要忘記前面提到的pickle只是python特有的操做，只能python才能操做，若是這樣的話是否是太侷限了？這時候json就有存在的意義了，它能夠跨語言進行數據交換，基本上大多數語言都支持json，若是是兩個跨語言的數據交換，json是最好的選擇，你只要說哥們json吧。可是有一點必須注意，json是不少語言都支持，這也致使了一些侷限性，有些python支持的數據類型，json不支持，所以json序列化通常爲字典和列表。

json的用法和pickle同樣，提供了四個功能：dumps、dump、loads、load。

實例：

 1 s = '{"desc":"ininia","status":200,"aaa":[11,22,33,44,55,66]}'
 2 s1 = {"desc":"ininia","status":200,"aaa":[11,22,33,44,55,66]}
 3 import json
 4 result = json.loads(s)#將字符串轉換成對象
 5 print result,type(result)
 6 #{u'status': 200, u'aaa': [11, 22, 33, 44, 55, 66], u'desc': u'ininia'} <type 'dict'>
 7 
 8 result1 = json.dumps(s1)#將對象轉換成字符串
 9 print result1,type(result1)
10 #{"status": 200, "aaa": [11, 22, 33, 44, 55, 66], "desc": "ininia"} <type 'str'>