Python-模塊

1、模塊：

　　Python中的模塊，就是一個保存了Python代碼的文件。模塊能定義函數，類和變量。模塊裏也能包好可執行的代碼。

　　文件名就是模塊名加上後綴.py，在模塊內部，模塊名存儲在全局變量__name__中，是一個string，能夠直接在模塊中經過__name__引用到模塊名。

　　模塊分爲三類：

　　　　-- 自定義模塊

　　　　-- 內置模塊

　　　　-- 第三方模塊

　　導入模塊：

　　　　-- import：使導入者以一個總體獲取一個模塊

　　　　-- from：使導入者從一個模塊文件中獲取特定的變量名

　　　　-- reload：在不終止Python程序的狀況下，提供了一個從新載入模塊文件代碼的方法

　　導入模塊的方法：

 1 import module # 會先把module執行一遍（若是裏邊有可執行程序）
 2 from module.xxx.xxx import xx
 3 from module.xxx.xxx import xx as rename
 4 from module.xxx.xxx import *   # 不推薦使用，由於裏邊可能有一些代碼，跟執行文件裏自定義的可執行代碼重複，致使覆蓋
 5 
 6 
 7 正確的調用方式:
 8 
 9 import cal #當前目錄直接調用模塊
10 
11 from my_module import cal  # 二層目錄調用
12 
13 from web1.web2.web3 import cal  # 多層目錄調用
14 
15 from web1.web2.web3.cal import add # 只調用某個方法
16 
17 
18 
19 注意：不支持的調用方式  （調用包就是執行包下的__init__.py文件） 20 from web1.web2 import web3  #這樣是執行web3的__init__文件，惟一不支持的調用方式
21 print(web3.cal.add(2,6))

 

　　獲取模塊的路徑：

 1 import sys
 2 print(sys.path)
 3 
 4 添加路徑：
 5 
 6 import sys
 7 import os
 8 # project_path=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 9 # sys.path.append(project_path)
10 print(os.path.abspath(__file__)) # 是獲取的文件名，路徑是pycharm加上的
11 print(os.path.dirname(os.path.abspath(__file__))) # 獲取文件的路徑
12 print(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) #獲取上一層目錄

 

　　第三方模塊：

 1 #先安裝 gcc 編譯和 python 開發環境
 2 yum install gcc
 3 yum install python-devel
 4 或
 5 apt-get python-dev
 6  
 7 #安裝方式（安裝成功後，模塊會自動安裝到 sys.path 中的某個目錄中）
 8 yum
 9 pip
10 apt-get
11 ...
12 #進入python環境，導入模塊檢查是否安裝成功

第三方模塊（linux）

 

2、包（package）

　　若是不一樣的人編寫的代碼模塊名相同怎麼辦？爲了不衝突，Python引入了按目錄來組織模塊的方法，稱爲包。

　　

　　如圖所示，兩個cal.py衝突了，可是功能不一樣，因此給兩個模塊選擇一個頂層包（不能重名），在調用就不會衝突了。

　　--注--：

　　　　請注意：每一個包目錄下來都會有一個__init__.py的文件，這個文件必須是存在的，不然，Python就不把這個目錄當成普通目錄，而不是一個包，__init__.py能夠是空文件，也能夠有python代碼，__init__.py自己就是一個文件，它的模塊名就是對應的包名，它通常因爲作接口文件。

　　　　調用包就是執行包下的__init__.py文件

3、time模塊　　

1 時間有三種表達方式：
2 
3 時間戳： unix元年到如今------>time.time()
4 格式化的字符串：如：2016-12-12 10:10------->time.strftime('%Y-%m-%d')
5 結構化時間：元組 ------>time.struct_time元組共有9個元素共九個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天，夏令時)    即：time.localtime()

 

　　

 1 import time
 2 
 3 # 一、時間戳
 4 print(time.time())
 5 
 6 # 二、localtime（）
 7 print(time.localtime())  # 空參
 8 ##time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0, tm_min=38, tm_sec=39, tm_wday=6, tm_yday=255, tm_isdst=0)
 9 
10 print(time.localtime(1422222222)) # 指定時間戳
11 
12 # 三、gmtime()
13 print(time.gmtime()) # gmtime()方法是將一個時間戳轉換爲UTC時區（0時區）的struct_time。
14 
15 
16 # 四、mktime（）
17 print(time.mktime(time.loacltime())) #將結構化時間轉換爲時間戳
18 
19 # 五、asctime()
20 print(time.asctime()) # 將結構化時間轉變爲：'Sun Jun 20 23:21:05 1993'
21 默認參數是time.localtime()
22 
23 # 六、ctime()
24 print(timectime()) #將時間戳轉化爲：'Sun Jun 20 23:21:05 1993'
25 默認參數是time.time()
26 
27 # 七、strftime()
28 print(time.strftime(format[,t])) #結構化時間轉化爲 字符串時間
29 默認參數time.localtime()
30 print(time.strftime('%Y-%m-%d %X',time.localtime())) # 2018-03-26 19:11:36
31 
32 # 八、strptime()
33 print(time.strptime())# 字符串時間轉化爲結構化時間
34 print(time.strptime('2016:12:23:17:20:20','%Y:%m:%d:%X')) # time.struct_time(tm_year=2016, tm_mon=12, tm_mday=23, tm_hour=17, tm_min=20, tm_sec=20, tm_wday=4, tm_yday=358, tm_isdst=-1)
35 
36 # 九、sleep（）
37 
38 # 十、clock（）
39 這個須要注意，在不一樣的系統上含義不一樣。
40 在UNIX系統上，它返回的是「進程時間」，它是用秒錶示的浮點數（時間戳）。
41 而在WINDOWS中，第一次調用，返回的是進程運行的實際時間。而第二次以後的調用是自第一次調用之後到如今的運行時間，即兩次時間差

 

　　　　　　　　記住以下圖便可：

 

　　　　---注---　　　　

1 import datetime
2 print(datetime.datetime.now())
3 ##2018-03-27 17:47:07.211182

4、random模塊　　

　　隨機數模塊：

 1 import random
 2  
 3 print(random.random())          #用於生成一個0到1的隨機符點數: 0 <= n < 1.0
 4 print(random.randint(1,2))      #用於生成一個指定範圍內的整數 [1,2]
 5 print(random.randrange(1,10))   #從指定範圍內，按指定基數遞增的集合中獲取一個隨機數 [1,10)
 6 print(random.uniform(1,10))     #用於生成一個指定範圍內的隨機符點數 9.49909962942907

 7 print(random.choice('nick'))    #從序列中獲取一個隨機元素 c
 8 li = ['nick','jenny','car',]
 9 random.shuffle(li)              #用於將一個列表中的元素打亂
10 print(li)
11 li_new = random.sample(li,2)    #從指定序列中隨機獲取指定長度的片段(從li中隨機獲取2個元素，做爲一個片段返回)
12 print(li_new)

 　　示例：驗證碼  查看：http://www.cnblogs.com/JerryZao/p/8659024.html

 5、os模塊：

　　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下爲"\\",Linux下爲"/"
14 os.linesep    輸出當前平臺使用的行終止符，win下爲"\r\n",Linux下爲"\n"
15 os.pathsep    輸出用於分割文件路徑的字符串 win下爲;,Linux下爲:
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所指向的文件或者目錄的最後修改時間

 

　　ps一、os.stat()　

 1 stat 結構:
 2 
 3 st_mode: inode 保護模式
 4 st_ino: inode節點號。
 5 st_dev: inode駐留的設備。
 6 st_nlink: inode 的連接數。
 7 st_uid: 全部者的用戶ID。
 8 st_gid: 全部者的組ID。
 9 st_size: 普通文件以字節爲單位的大小；包含等待某些特殊文件的數據。
10 st_atime: 上次訪問的時間。
11 st_mtime: 最後一次修改的時間。
12 st_ctime: 建立時間，由操做系統報告的"ctime"。在某些系統上（如Unix）是最新的元數據更改的時間，在其它系統上（如Windows）是建立時間（詳細信息參見平臺的文檔）。

 

6、sys模塊

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       返回操做系統平臺名稱

1 import time sys
2 
3 for i in range(100):
4     sys.stdout.write("*")
5     time.sleep(1)
6     sys.stdout.flush()

進度條

 

7、json 和 pickle模塊

　　用於序列化的兩個模塊;

　　　　json：用於字符串和Python數據類型間的進行轉換

　　　　pickle：用於Python特有的類型 和P一條紅的數據類型間的轉換　

　　　　以前學過eval內置方法，能夠將字符串轉換爲python對象，可是侷限性很大，通常eval只用於字符串表達式。

　　什麼是序列化：

　　　　咱們把對象（變量）從內存中變爲可存儲或可傳輸的過程稱之爲序列化。

　　　　序列化以後，就能夠吧序列化後的內容寫入磁盤，或者經過網絡傳輸到別的機器上

　　json模塊 提供了四個功能：dumps  dump  loads load

　　pickle模塊也是同樣的四個功能。

　　　　dump() 函數接受一個文件句柄和一個數據對象做爲參數，把數據對象以特定的格式保存到給定的文件中，當咱們使用load()函數從文件中讀取已保存的對象時，picle知道如何恢復這些對象到他們原本的格式

　　　　dumps() 函數執行和dump() 函數相同的序列化，取代接受流對象並將序列化後的數據保存到磁盤文件，這個函數簡單的返回序列化的數據

　　　　loads() 函數執行和load() 函數同樣的反序列化，取代接受一個流對象並去文件都序列化後的數據，它就收包含序列化後的數據的str對象，直接返回的對象

　　　　　　　　　

　　eval()方法：

　　　　一、

1 import json
2 
3 dic = '{"jakc":12}' 
4 f = open('c.txt','w')
5 f.write(dic)

　　　　二、

1 f = open('c.txt','r')
2 data = f.read()
3 print(type(data))
4 data1 = eval(data)
5 print(data1['jakc'])

　　json模塊：

　　　　一、把字典轉換成json形式的字符串寫入文件中 （兩種方法效果同樣，只是寫法不一樣而已）

 1 #-----------方法一--------推薦使用
 2 
 3 dic = {'age':12}
 4 dic = json.dumps(dic)
 5 print(dic) # {"age": 12} 內部都是用雙引號，json格式
 6 f = open('c.txt','w')
 7 f.write(dic)
 8 f.close()
 9 
10 #-----------方法二
11 
12 dic = {'age':13}
13 f = open('d.txt','w')
14 json.dump(dic,f)

 

　　　　二、json反序列化 

 1 把文件中json類型的字符串讀取出來轉換成字典
 2 
 3 #------------------方法一---推薦
 4 f = open('d.txt','r')
 5 a = json.loads(f.read())
 6 print(a)
 7 print(type(a))
 8 
 9 #------------------方法二
10 f = open('c.txt','r')
11 b = json.load(f)
12 print(b)
13 print(type(b))

 

　　　--注---

1 import json
2 #dct="{'1':111}"#json 不認單引號
3 #dct=str({"1":111})#報錯,由於生成的數據仍是單引號:{'one': 1}
4 
5 dct='{"1":"111"}'
6 print(json.loads(dct))
7 
8 #conclusion:
9 #        不管數據是怎樣建立的，只要知足json格式，就能夠json.loads出來,不必定非要dumps的數據才能loads

 

　　

json的dumps，loads，dump，load功能總結：

json.dumps(x)    把python的(x)原對象轉換成json字符串的對象，主要用來寫入文件。

json.loads(f)       把json字符串(f)對象轉換成python原對象，主要用來讀取文件和json字符串

json.dump(x,f)　 把python的(x)原對象,f是文件對象，寫入到f文件裏面，主要用來寫入文件的

json.load(file)　　把json字符串的文件對象，轉換成python的原對象，只是讀文件

　　pickle模塊

　　　　　pickle轉換後的結果是bytes　　　　

1 pickle序列化：
2 
3 dic = {'name':'jakc','age':12}
4 j = pickle.dumps(dic)
5 f = open('e.txt','wb')
6 f.write(j)    # 等價pickle.dump(fic,f)
7 f.close()

 

1 pickle反序列化：
2 
3 f = open('e.txt','rb')
4 data = pickle.loads(f.read()) # 等價 data = pickle.load(f)
5 print(data)

 

　　Pickle的問題和全部其餘編程語言特有的序列化問題同樣，就是它只能用於Python，而且可能不一樣版本的Python彼此都不兼容，所以，只能用Pickle保存那些不重要的數據，不能成功地反序列化也不要緊。

8、shelve模塊

　　shelve模塊比pickle模塊簡單，只有一個open函數，返回相似字典的對象，可讀可寫，key必須是字符串

# 添加鍵值對到文件中，會生成三個文件，並寫入字典內容

import shelve

f = shelve.open(r'sssss') # 目的：將一個字典寫入文本 f={}
print(f)
f['a1']= {'name':'alex','age':12}
f['a2']= {'name':'jakc','age':12}
f['b1']= {'a':'aa','b':'bb'}
f.close()




-----------------------------------------------------------------------------
會生成三個文件：sssss.dat,sssss.dir,sssss.bak,其中sssss.bak中內容以下：
'a1', (0, 42)
'a2', (512, 42)
'b1', (1024, 42)

 

1 # 取值：
2 
3 f = shelve.open(r'sssss')
4 print(f.get('a1')['name'])

 

9、xml模塊

　　xml 是實現不一樣語言或程序之間進行數據交換的協議，跟json差很少，可是json簡單。

　　xml的格式以下：

 1 <?xml version="1.0"?>
 2 <data>   #根
 3     <country name="Liechtenstein">  #節點
 4         <rank updated="yes">2</rank>
 5         <year>2008</year>
 6         <gdppc>141100</gdppc>
 7         <neighbor name="Austria" direction="E"/>  
 8         <neighbor name="Switzerland" direction="W"/>  
 9     </country>
10     <country name="Singapore">     #節點
11         <rank updated="yes">5</rank>
12         <year>2011</year>
13         <gdppc>59900</gdppc>
14         <neighbor name="Malaysia" direction="N"/>
15     </country>
16     <country name="Panama">      #節點
17         <rank updated="yes">69</rank>
18         <year>2011</year>
19         <gdppc>13600</gdppc>
20         <neighbor name="Costa Rica" direction="W"/>
21         <neighbor name="Colombia" direction="E"/>
22     </country>
23 </data>
24 
25 xml數據

樣例

　　xml在各個語言裏都是支持的，在python中可使用xml模塊操做xml文件 。

 1 # 基本操做1：
 2 
 3 import xml.etree.ElementTree as ET
 4 
 5 tree = ET.parse("test.xml") # 獲取一個xml文件對象
 6 root = tree.getroot()
 7 print(root.tag) # 獲取跟節點的標籤 data
 8 
 9 遍歷xml文檔
10 for i in root:
11     print(i.tag,i.attrib) # 根節點下的標籤，一級屬性名，屬性值
12     for j in i:
13         print(j.tag,j.attrib) # 在往下一層的節點，和屬性
14 
15 只遍歷year節點
16 for i in root.iter('year'):
17     print(i.tag,i.text)
18 
19 ----->
20 year 2008
21 year 2011
22 year 2011

 

 1 # 基本操做2：
 2 
 3 import xml.etree.ElementTree as ET
 4 
 5 tree = ET.parse("test.xml") # 獲取一個xml文件對象
 6 root = tree.getroot()
 7 
 8 # 修改
 9 for i in root.iter('year'):
10     print(i)
11     new_year = int(i.text) + 1
12     i.text = str(new_year)
13     i.set('update','yes') # 增長一個屬性
14 
15 tree.write('new_test.xml') # 將內存中修改後的，寫到文件中，也能夠直接寫到原文件中覆蓋
16 
17 # 刪除節點
18 for i in root.findall('country'): # 找到全部的country
19     rank = int(i.find('rank').text)# 某個country下找rank
20     if rank > 50:
21         root.remove(i)  # 刪除符合條件的節點
22 
23 tree.write('new_test2.xml')

 

　　如何本身建立一個xml文檔：

 1 import xml.etree.ElementTree as ET  # as後面的ET是前面的類的別名，名稱隨便取
 2 
 3 new_xml = ET.Element("namelist")
 4 name = ET.SubElement(new_xml, "name", attrib={"enrolled": "yes"})
 5 
 6 age = ET.SubElement(name, "age", attrib={"checked": "no"})
 7 sex = ET.SubElement(name, "sex")
 8 sex.text = '33'
 9 
10 name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"})
11 
12 age = ET.SubElement(name2, "age")
13 age.text = '19'
14 
15 # 不懂記住就行
16 et = ET.ElementTree(new_xml)  # 生成文檔對象  （記住重點）
17 et.write("test.xml", encoding="utf-8", xml_declaration=True) # （記住重點）
18 
19 ET.dump(new_xml)  # 打印生成的格式

 

10、configparser模塊

　　用來處理配置文件的

　　一、配置文件格式：

 1 [DEFAULT]
 2 ServerAliveInterval = 45
 3 Compression = yes
 4 CompressionLevel = 9
 5 ForwardX11 = yes
 6   
 7 [bitbucket.org]
 8 User = hg
 9   
10 [topsecret.server.com]
11 Port = 50022
12 ForwardX11 = no

 

　　二、寫一個配置文件

 1 import configparser
 2 
 3 config = configparser.ConfigParser()     #config={}
 4 
 5 config["DEFAULT"] = {'ServerAliveInterval': '45',
 6                      'Compression': 'yes',
 7                      'CompressionLevel': '9'}
 8 
 9 with open('example1.ini', 'w') as f:
10     config.write(f)
11 
12 
13 ---------> 生成example.ini文件
14 
15 [DEFAULT]
16 compressionlevel = 9
17 compression = yes
18 serveraliveinterval = 45

 

　　三、生成一個多鍵值對的配置文件

 1 import configparser
 2 
 3 config = configparser.ConfigParser()     #config={}
 4 
 5 config["DEFAULT"] = {'ServerAliveInterval': '45',
 6                      'Compression': 'yes',
 7                      'CompressionLevel': '9'}
 8 
 9 config['bitbucket.org'] = {}
10 config['bitbucket.org']['User'] = 'hg'
11 
12 config['topsecret.server.com'] = {}
13 topsecret = config['topsecret.server.com']
14 topsecret['Host Port'] = '50022'      # mutates the parser
15 topsecret['ForwardX11'] = 'no'        # same here
16 
17 with open('example1.ini', 'w') as f:
18     config.write(f)
19 
20 
21 
22 -------------->
23 
24 #會生成example1.ini文件，內容以下：
25 
26 [DEFAULT]
27 compression = yes
28 compressionlevel = 9
29 serveraliveinterval = 45
30 
31 [bitbucket.org]
32 user = hg
33 
34 [topsecret.server.com]
35 host port = 50022
36 forwardx11 = no

 

　　四、對配置文件實現查詢功能：

　　　　4.一、找出相應的值

1 import configparser
2 
3 config = configparser.ConfigParser() # config對象
4 config.read('example.ini')
5 print(config['bitbucket.org']['User']) # 不區分大小寫  輸出 hg

　　　　4.二、若是去bitbucket.org鍵的值，它會把DEFAULT的一塊兒打印出來，DEFAULT的特殊功能：由於只要帶DEFAULT鍵值對的，他就會把DEFAULT的鍵打印出來

 1 config = configparser.ConfigParser()
 2 config.read('example.ini')
 3 
 4 for key in config['bitbucket.org']:
 5     print(key)
 6 
 7 -------->輸出
 8 
 9 user
10 compression
11 compressionlevel
12 serveraliveinterval

　　　　4.三、取的是bitbucket.org鍵的值，以列表的方式打印出來

1 config = configparser.ConfigParser()
2 config.read('example.ini')
3 print(config.options('bitbucket.org'))
4 
5 #['user', 'compression', 'compressionlevel', 'serveraliveinterval']

 

’　　　　4.四、取的是bitbucket.org鍵和值，以元組的方式打印出來

1 import configparser
2 
3 config = configparser.ConfigParser()
4 config.read('example1.ini')
5 print(config.items('bitbucket.org')) 

-------> 輸出

1 [('compression', 'yes'), ('compressionlevel', '9')，('serveraliveinterval', '45'), ('user', 'hg')]

　　　　4.五、連續取值，取出compression的值

1 import configparser
2 
3 config = configparser.ConfigParser()
4 config.read('example.ini')
5 
6 print(config.get('bitbucket.org','compression'))   #取出compression的值 yes
7 print(config.get('bitbucket.org','user'))   #取出compression的值 hg

　　五、增長功能：

　　　　實現：在example1.txt文件中讀取原來塊的內容，增長一個新的塊

 1 import configparser
 2 
 3 config = configparser.ConfigParser()
 4 config.read('example.ini')
 5 
 6 config.add_section('jerry') #添加一個快
 7 config.set('jerry','key','zao') #添加鍵值
 8 
 9 
10 config["DEFAULT2"] = {'ServerAliveInterval': '45', # 直接用建立example.ini的方法也能夠
11                      'Compression': 'yes',
12                      'CompressionLevel': '9'}
13 
14 config.write(open('example.ini','w')) #寫入 新文件 並覆蓋

　　6 、刪除

1 import configparser
2 
3 config = configparser.ConfigParser()
4 config.read('example.ini')
5 config.remove_section('DEFAULT2') # 刪除整個塊
6 config.remove_option('jerry','key') # 刪除塊下的一對鍵值
7 config.write(open('example.ini','w'))

 

11、logging模塊

　　一、簡單顯示：

import logging  

logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')


-------------->輸出：默認級別是warning ，debug級別最低，只顯示默認級別以及高級別的


1 WARNING:root:warning message
2 ERROR:root:error message
3 CRITICAL:root:critical message 

 

　　二、給logging加上參數，並保存到一個文件中

 1 import logging
 2 logging.basicConfig(
 3 
 4     level= logging.DEBUG, # 默認級別
 5     filename='logger.log', # 保存爲何名字
 6     filemode='w',# 每次只寫5條記錄，默認是追加模式
 7     format = '%(asctime)s %(filename)s [%(lineno) d] %(message)s' #asctime 時間，lineno 行號，message 信息，還能夠加其它信息參數
 8 )
 9 
10 logging.debug('debug message')
11 logging.info('info message')
12 logging.warning('warning message')
13 logging.error('error message')
14 logging.critical('critical message')
15 
16 
17 -------------->輸出
18 
19 
20 2018-03-29 11:41:17,742 logging模塊.py [ 10] debug message
21 2018-03-29 11:41:17,787 logging模塊.py [ 11] info message
22 2018-03-29 11:41:17,787 logging模塊.py [ 12] warning message
23 2018-03-29 11:41:17,787 logging模塊.py [ 13] error message
24 2018-03-29 11:41:17,787 logging模塊.py [ 14] critical message

 

　　--注--　　　　

可見在logging.basicConfig()函數中可經過具體參數來更改logging模塊默認行爲，可用參數有
filename：用指定的文件名建立FiledHandler（後邊會具體講解handler的概念），這樣日誌會被存儲在指定的文件中。
filemode：文件打開方式，在指定了filename時使用這個參數，默認值爲「a」還可指定爲「w」。
format：指定handler使用的日誌顯示格式。 
datefmt：指定日期時間格式。 
level：設置rootlogger（後邊會講解具體概念）的日誌級別 
stream：用指定的stream建立StreamHandler。能夠指定輸出到sys.stderr,sys.stdout或者文件(f=open('test.log','w'))，默認爲sys.stderr。若同時列出了filename和stream兩個參數，則stream參數會被忽略。

format參數中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 數字形式的日誌級別
%(levelname)s 文本形式的日誌級別
%(pathname)s 調用日誌輸出函數的模塊的完整路徑名，可能沒有
%(filename)s 調用日誌輸出函數的模塊的文件名
%(module)s 調用日誌輸出函數的模塊名
%(funcName)s 調用日誌輸出函數的函數名
%(lineno)d 調用日誌輸出函數的語句所在的代碼行
%(created)f 當前時間，用UNIX標準的表示時間的浮 點數表示
%(relativeCreated)d 輸出日誌信息時的，自Logger建立以 來的毫秒數
%(asctime)s 字符串形式的當前時間。默認格式是 「2003-07-08 16:49:45,896」。逗號後面的是毫秒
%(thread)d 線程ID。可能沒有
%(threadName)s 線程名。可能沒有
%(process)d 進程ID。可能沒有
%(message)s用戶輸出的消息

　　三、自定義日誌格式（重點）

　　上述幾個例子中咱們瞭解到了logging.debug()、logging.info()、logging.warning()、logging.error()、logging.critical()（分別用以記錄不一樣級別的日誌信息），logging.basicConfig()（用默認日誌格式
（Formatter）爲日誌系統創建一個默認的流處理器（StreamHandler），設置基礎配置（如日誌級別等）並加到root logger（根Logger）中）這幾個logging模塊級別的函數，另外還有一個模塊級別的函數
是logging.getLogger([name])（返回一個logger對象，若是沒有指定名字將返回root logger）

　　　　3.一、示例，自定義一個日誌

 1 import logging
 2 
 3 logger = logging.getLogger() # 建立一個root根對象
 4 
 5 fh = logging.FileHandler('test_log') #定義一個文件，並用於保存內容
 6 ch = logging.StreamHandler() # 將內容發送到屏幕
 7 
 8 fm = logging.Formatter("%(asctime)s  %(message)s") # 設置日誌格式
 9 
10 fh.setFormatter(fm)  # 將設置的格式，用到文件中
11 ch.setFormatter(fm) # 將設置的格式用於屏幕打印中
12 
13 logger.addHandler(fh) # 吸取fh，將fh吃掉
14 logger.addHandler(ch)
15 
16 logger.debug("debug")   #輸出日誌的級別
17 logger.info("info")
18 logger.warning("warning")
19 logger.error("error")
20 logger.critical("critical")

 

　　　　3.二、logger.setLevel("DEBUG")   調整日誌級別，控制日誌顯示信息，DEBUG顯示5條記錄

 　　1 import logging
 2 
 3 import logging
 4 
 5 logger=logging.getLogger()         #建立一個大對象
 6 
 7 fh=logging.FileHandler("test_log") #向文件裏發送內容，而且給個參數，做用是：定義一個文件名，往文件裏寫入內容
 8 ch=logging.StreamHandler()         #向屏幕上發送內容
 9 
10 fm=logging.Formatter("%(asctime)s  %(message)s")   #這個也是一個對象，做用是：定義日誌格式
11 
12 fh.setFormatter(fm)      #往文件裏寫內容
13 ch.setFormatter(fm)      #往屏幕上輸出內容
14 
15 logger.addHandler(fh)    #對象，相似於吸別人內力，把fh吃掉
16 logger.addHandler(ch)    #對象，相似於吸別人內力，把ch吃掉
17 logger.setLevel("DEBUG") #設置日誌級別，控制日誌輸入多少條信息
18 
19 
20 #-------------從這裏開始都是在操做log----------------
21 
22 logger.debug("debug")   #輸出日誌的級別
23 logger.info("info")
24 logger.warning("warning")
25 logger.error("error")
26 logger.critical("critical")

 

　　　　3.三、寫成函數的形式，並有返回值

 1 import logging
 2 
 3 def logger():
 4 
 5     logger=logging.getLogger()         #建立一個大對象
 6 
 7     fh=logging.FileHandler("test_log") #向文件裏發送內容，而且給個參數，做用是：定義一個文件名，往文件裏寫入內容
 8     ch=logging.StreamHandler()         #向屏幕上發送內容
 9 
10     fm=logging.Formatter("%(asctime)s  %(message)s")   #這個也是一個對象，做用是：定義日誌格式
11 
12     fh.setFormatter(fm)       #往文件裏寫內容
13     ch.setFormatter(fm)       #往屏幕上輸出內容
14 
15     logger.addHandler(fh)     #對象，相似於吸別人內力，把fh吃掉
16     logger.addHandler(ch)     #對象，相似於吸別人內力，把ch吃掉
17     logger.setLevel("DEBUG")  #設置日誌級別，控制日誌輸入多少條信息
18 
19     return logger
20 
21 #-------------從這裏開始都是在操做log----------------
22 logger=logger()         #這個日誌就作成了一個接口，想在其它地方使用，直接調用他就能夠啦！
23 
24 logger.debug("debug")   #輸出日誌的級別
25 logger.info("info")
26 logger.warning("warning")
27 logger.error("error")
28 logger.critical("critical")

　　　　3.四、沒有root用戶，建立兩個logger對象

 1 import logging
 2 
 3 logger1 = logging.getLogger('mylogger')   #默認是根，這裏表明他是子用戶（兩個用戶是同級）
 4 #logger1 = logging.getLogger('mylogger.sontree')   #若是mylogger下再建立一個字對象，就用.sontree;等於他就是mylogger的下級對象。
 5 logger1.setLevel(logging.DEBUG)           #第一次是DEBUG級別
 6 
 7 logger2 = logging.getLogger('mylogger')   #默認是根，這裏表明他是子用戶（兩個用戶是同級）
 8 logger2.setLevel(logging.INFO)            #第二次是INFO級別，覆蓋第一次的級別，因此打印結果是INFO級別顯示
 9 
10 fh=logging.FileHandler("test_log-new")    #向文件裏發送內容，而且給個參數，做用是：定義一個文件名，往文件裏寫入內容
11 ch=logging.StreamHandler()                #向屏幕上發送內容
12 
13 logger1.addHandler(fh)
14 logger1.addHandler(ch)
15 
16 logger2.addHandler(fh)
17 logger2.addHandler(ch)

 

 1 -----------------------》文件和屏幕
 2 logger1 and logger2各打印4條信息
 3 生成一個test_log-new的文件，同時往裏面寫入信息，並在屏幕上面顯示相同信息。
 4 文件內容以下：
 5 logger1 info message
 6 logger1 warning message
 7 logger1 error message
 8 logger1 critical message
 9 logger2 info message
10 logger2 warning message
11 logger2 error message
12 logger2 critical message
13 
14 #屏幕上面顯示的內容
15 logger1 info message
16 logger1 warning message
17 logger1 error message
18 logger1 critical message
19 logger2 info message
20 logger2 warning message
21 logger2 error message
22 logger2 critical message

 

　　　　PS：根據以上結果，能夠知道，在同一個根下，不能建立兩個名字同樣的子根

 

　　　　3.五、添加根用戶（logger和mylogger是父子關係），注意日誌輸出問題

 1 import logging
 2 
 3 logger = logging.getLogger()              #根用戶(根用戶級別，沒有定義日誌級別，默認warning級別，因此是3條信息
 4 
 5 logger1 = logging.getLogger('mylogger')   #默認是根，這裏表明他是子用戶（兩個用戶是同級）
 6 logger1.setLevel(logging.DEBUG)           #第一次是DEBUG級別,默認是打印五條信息，可是他打印信息的時候，會先去找父，若是有父，他就會多打印一遍，因此輸出是10條信息
 7 
 8 fh=logging.FileHandler("test_log-new")    #向文件裏發送內容，而且給個參數，做用是：定義一個文件名，往文件裏寫入內容
 9 ch=logging.StreamHandler()                #向屏幕上發送內容
10 
11 logger.addHandler(ch)                     #添加一個根用戶
12 logger.addHandler(fh)
13 
14 logger1.addHandler(fh)                    #添加一個子用戶
15 logger1.addHandler(ch)
16 
17 #打印信息
18 logger.debug('logger debug message')
19 logger.info('logger info message')
20 logger.warning('logger warning message')
21 logger.error('logger error message')
22 logger.critical('logger critical message')
23 
24 #打印4條信息
25 logger1.debug('logger1 debug message')
26 logger1.info('logger1 info message')
27 logger1.warning('logger1 warning message')
28 logger1.error('logger1 error message')
29 logger1.critical('logger1 critical message')

 

 1 ---------------->輸出
 2 
 3 生成一個test_log-new的文件，同時往裏面寫入信息，並在屏幕上面顯示相同信息。
 4 文件內容以下：
 5 logger warning message
 6 logger error message
 7 logger critical message    #前三條是根輸出的三條信息
 8 logger1 debug message      #後10條是子輸出的10條信息，爲何會輸入10條呢？
 9 logger1 debug message      #第一次是DEBUG級別,默認是打印五條信息，可是他打印信息的時候，會先去找父，若是有父，他就會多打印一遍，因此輸出是5+5=10條信息
10 logger1 info message
11 logger1 info message
12 logger1 warning message
13 logger1 warning message
14 logger1 error message
15 logger1 error message
16 logger1 critical message
17 logger1 critical message
18 
19 屏幕輸出內容以下：
20 logger warning message
21 logger error message
22 logger critical message    
23 logger1 debug message
24 logger1 debug message
25 logger1 info message
26 logger1 info message
27 logger1 warning message
28 logger1 warning message
29 logger1 error message
30 logger1 error message
31 logger1 critical message
32 logger1 critical message

 

　　　　PS：以上結果能夠看到，有root根handler輸出時，root的下一層，既會將消息分發給他的handler進行處理也會傳遞給全部的祖先Logger處理

12、hashlib模塊

hashlib 明文變成密文，不能反解
用於加密相關的操做，3.x裏代替了md5模塊和sha模塊，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

md5算法 明文變成密文

 1 import hashlib
 2 
 3 obj = hashlib.md5()
 4 obj.update('jerry'.encode('utf-8'))
 5 print(obj.hexdigest()) # 30035607ee5bb378c71ab434a6d05410 32位
 6 
 7 -------------------------------------------------------------------------
 8 import hashlib
 9 
10 #md5加密+字符串，給元字符串加鹽
11 obj=hashlib.md5("sssdsdsb".encode("utf8"))   #在md5裏面加點字符串，再生成，就無法破解
12 obj.update("admin".encode("utf8"))
13 
14 print(obj.hexdigest())
15 
16 -------------------------------------------------------------------------
17 python 還有一個 hmac 模塊，它內部對咱們建立 key 和 內容 再進行處理而後再加密:
18 import hmac
19 h = hmac.new('jerry'.encode('utf-8'))
20 h.update('hello'.encode('utf-8'))
21 print(h.hexdigest())