常見模塊（續上次）

一.time模塊

　　經常使用方法：

        time.time()   獲取當前時間戳

        time.sleep(t)  推遲指定的時間運行

　　1.表示時間的三種方式：

　　 時間戳，格式化的時間字符串，時間元組

 1 #時間戳：
 2 print(time.time())
 3 #1502176744.8150175
 4 
 5 #格式化時間字符串
 6 print(time.strftime('%Y/%m/%d %H:%M:%S'))
 7 2017/08/08 15:27:19
 8 
 9 #時間元組
10 #localtime將一個時間戳轉換爲當前時區的struct_time
11 t = time.local()
12 #time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=15, tm_min=30, tm_sec=45, tm_wday=1, tm_yday=220, tm_isdst=0)

　　 總結：小結：時間戳是計算機可以識別的時間；時間字符串是人可以看懂的時間；元組則是用來操做時間的

#幾種格式之間的轉換

#時間戳-->結構化時間
#time.gmtime()  #英國倫敦當地時間 UTC
#time.localtime() #當地時間

#結構化時間-->時間戳
#time_tuple = time.localtime(1500000000)
#time.mktime(time_tuple)
#1500000000.0

#結構化時間-->字符串格式化時間
#time.strftime("%Y-%m-%d",time.localtime(1500000000))
#'2017-07-14'

#字符串格式化時間-->結構化時間
#time.strptime("07/24/2017","%m/%d/%Y")
#time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)

#結構化時間-->%a %d %d %H:%M:%S %Y串
#time.asctime(time.localtime(1500000000))
#'Fri Jul 14 10:40:00 2017'
#time.asctime()
#'Mon Jul 24 15:18:33 2017'

#%a %d %d %H:%M:%S %Y串 --> 結構化時間
#time.ctime(時間戳)  若是不傳參數，直接返回當前時間的格式化串
#time.ctime()
#'Tue Aug  8 15:56:20 2017'
#time.ctime(1500000000)
#'Fri Jul 14 10:40:00 2017' 

二.random模塊

#import time

#隨機小數
#random.random()     (0-1小數)
#0.9167746266539144
#random.uniform(1,3)  (1-3小數)
#1.9542609515193614

#隨機整數
#random. randint(1,5)  (1-5間隨機整數，可取到5)
#2

#隨機選擇一個或者多個返回
#random.choice(1,5,[5,6])
#random.sample([[4,5],[89,58],99,66],2)
#2爲返回的個數

#打亂列表順序
#li = [4,5,6,8,2,7]
#random.shuffle(li)  (返回值爲None)
#print(li)
#[5, 6, 2, 7, 8, 4]  (每次返回結果順序不同)

三.os模塊

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

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

四.sys模塊

　　sys模塊是與python解釋器交互的一個接口

#sys.argv           命令行參數List，第一個元素是程序自己路徑
#sys.exit(n)        退出程序，正常退出時exit(0)
#sys.version        獲取Python解釋程序的版本信息
#sys.maxint         最大的Int值
#sys.path           返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
#sys.platform       返回操做系統平臺名稱

五.序列化模塊

　　序列化定義:將本來列表、字典等內容專戶爲字符串的過程

　　eval():將字符串str當成有效的表達式來求值並返回計算結果

　　缺點：雖然eval()也能實現此功能，可是安全性差

　　一、以某種存儲形式使自定義對象持久化；

　　二、將對象從一個地方傳遞到另外一個地方。

 

　　三、使程序更具維護性。

 

　　對象持久化(對象持久化是指將內存中的對象保存到可永久保存的存儲設備中（如磁盤）的一種技術)

　　Json模塊（dump，dumps,load,loads）

#dumps loads  
# import json
# dic = {'k1':56,'k2':85,'k3':'egon'}
# dic_str = json.dumps(dic)
# print(type(dic_str),dic_str) #序列化
# <class 'str'> {"k1": 56, "k2": 85, "k3": "egon"}
# str_dict = json.loads(dic_str)
# print(type(str_dict),str_dict) #反序列化
# <class 'dict'> {'k1': 56, 'k2': 85, 'k3': 'egon'}

#也可嵌套使用
# import json
# l = [1,[1,2,3],{'k1':'egon','k2':'alex'},5]
# l_str = json.dumps(l)
# print(type(l_str),l_str)
# # <class 'str'> [1, [1, 2, 3], {"k1": "egon", "k2": "alex"}, 5]
# str_l = json.loads(l_str)
# print(type(str_l),str_l)
 # <class 'list'> [1, [1, 2, 3], {'k1': 'egon', 'k2': 'alex'}, 5]

import json
# f1 = open('json_file','w')
# dic = {'k1':'zhiku','k2':'huawei','k3':'chuanqi'}
# json.dump(dic,f1)
# f.close()
 #dump方法接收一個文件句柄，直接將字典轉換成json字符串寫入文件

# f2 = open('json_file')
# dic1 = json.load(f2)
# print(type(dic1),dic1)
# <class 'dict'> {'k1': 'zhiku', 'k2': 'huawei', 'k3': 'chuanqi'}
 #load方法接收一個文件句柄，直接將文件中的json字符串轉換成數據結構返回

　　json&pickle模塊

• json，用於字符串 和 python數據類型間進行轉換
• pickle，用於python特有的類型 和 python的數據類型間進行轉換
• pickle模塊提供了四個功能：dumps、dump(序列化，存）、loads（反序列化，讀）、load  （不只能夠序列化字典，列表...能夠把python中任意的數據類型序列化）

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二進制內容
#b'\x80\x03}q\x00(X\x02\x00\x00\x00k1q\x01X\x02\x00\x00\x00v1q\x02X\x02\x00\x00\x00k2q\x03X\x02\x00\x00\x00v2q\x04X\x02\x00\x00\x00k3q\x05X\x02\x00\x00\x00v3q\x06u.'

dic2 = pickle.loads(str_dic)
print(dic2)    #字典
#{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
#time.struct_time(tm_year=2001, tm_mon=9, tm_mday=9, tm_hour=9, tm_min=46, tm_sec=40, tm_wday=6, tm_yday=252, tm_isdst=0)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time.tm_year)
#2001

　　shelve模塊

　　shelve只提供給咱們一個open方法，是用key來訪問的，使用起來和字典相似。

#import shelve
# f = shelve.open('shelve_file')
# f['key'] ={'k1':'niucha','k2':'daoxiang','k3':'egon'}#若是k不存在則報錯
# f.close()
# 
# f1 = shelve.open('shelve_file')
# existing = f1['key']
# f1.close()
# print(existing) 
# {'k1': 'niucha', 'k2': 'daoxiang', 'k3': 'egon'}

 

　　這個模塊有個限制：不支持多個程序同一時間往同一個文件中進行寫操做，若是隻是讀文件，能夠用其打開。

　　shelve在默認狀況下是不會記錄待持久化對象的任何修改的，因此咱們在shelve.open()時候須要修改默認參數，不然對象的修改不會保存。

# import shelve
# f = shelve.open('shelve_file')
# print(f['key'])
# f['key']['new_value'] = 'this is a beautiful girl'
# print(f['key'])
# f.close()

# import shelve
# f1 = shelve.open('shelve_file',writeback=True)
# print(f1['key'])
# f1['key']['new_value'] = 'this is a beautiful girl'
# print(f1['key'])
# f1.close()
#{'k1': 'niucha', 'k2': 'daoxiang', 'k3': 'egon', 'new_value': 'this is a beautiful girl'}

 六.經常使用模塊二

　　1.hashlib模塊(提供常見MD5，SHA1摘要算法)　

　　什麼是摘要算法呢？摘要算法又稱哈希算法、散列算法。它經過一個函數，把任意長度的數據轉換爲一個長度固定的數據串（一般用16進制的字符串表示）。

　　摘要算法就是經過摘要函數f()對任意長度的數據data計算出固定長度的摘要digest，目的是爲了發現原始數據是否被人篡改過。

　　摘要算法之因此能指出數據是否被篡改過，就是由於摘要函數是一個單向函數，計算f(data)很容易，但經過digest反推data卻很是困難。並且，對原始數據作一個bit的修改，都會致使計算出的摘要徹底不一樣。

#計算MD5值
import hashlib
md5_obj = hashlib.md5()
md5_obj.update('iloveyou'.encode('utf-8'))
print(md5_obj.hexdigest())
# f25a2fc72690b780b2a14e140ef6a9e0


#計算SHA1值
import hashlib
sha1 = hashlib.sha1()
sha1.update('i care you '.encode('utf-8'))
sha1.update('are you know?'.encode('utf-8'))
print(sha1.hexdigest())
#64540be8d040c9b5502f431c40ae5354612838c8

#加鹽
#因爲經常使用口令的MD5值很容易被計算出來，因此，要確保存儲的用戶口令不是那些已經被計算出來的經常使用口令的MD5，這一方法經過對原始口令加一個複雜字符串來實現，俗稱「加鹽」：
#hashlib.md5("salt".encode("utf8"))

　　文件校驗

# import os
# import hashlib
# md5_obj = hashlib.md5('egon'.encode('utf-8'))
# # md5_obj = hashlib.md5()
# f = open('filename','rb')
# filesize = os.path.getsize('filename')
# while filesize > 0:
#     if filesize > 1024:
#         content = f.read(1024)
#         filesize -= 1024
#     else:
#         content = f.read(filesize)
#         filesize -= filesize
#     # for line in f:
#     #     md5_obj.update(line.encode('utf-8'))
#     md5_obj.update(content)
#     print(md5_obj.hexdigest())
# import hashlib
# md5_obj = hashlib.md5()
# md5_obj.update('iloveyou'.encode('utf-8'))
# print(md5_obj.hexdigest())
# # f25a2fc72690b780b2a14e140ef6a9e0

 　　2.logging模塊

　　函數式簡單配置

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

　　默認狀況下Python的logging模塊將日誌打印到了標準輸出中，且只顯示了大於等於WARNING級別的日誌，這說明默認的日誌級別設置爲WARNING（日誌級別等級CRITICAL > ERROR > WARNING > INFO > DEBUG），默認的日誌格式爲日誌級別：Logger名稱：用戶輸出消息。

　　配置日誌級別，日誌格式，輸出位置

import logging  
logging.basicConfig(level=logging.DEBUG,  
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  
                    datefmt='%a, %d %b %Y %H:%M:%S',  
                    filename='/tmp/test.log',  
                    filemode='w')  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')

　　參數詳解：

logging.basicConfig()函數中可經過具體參數來更改logging模塊默認行爲，可用參數有：

filename：用指定的文件名建立FiledHandler，這樣日誌會被存儲在指定的文件中。
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用戶輸出的消息

　　logger對象配置

import logging

logger = logging.getLogger()
# 建立一個handler，用於寫入日誌文件
fh = logging.FileHandler('test.log')

# 再建立一個handler，用於輸出到控制檯
ch = logging.StreamHandler()

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh.setFormatter(formatter)
ch.setFormatter(formatter)

logger.addHandler(fh) #logger對象能夠添加多個fh和ch對象
logger.addHandler(ch)

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

　　logging庫提供了多個組件：Logger、Handler、Filter、Formatter。Logger對象提供應用程序可直接使用的接口，Handler發送日誌到適當的目的地，Filter提供了過濾日誌信息的方法，Formatter指定日誌顯示格式。另外，能夠經過：logger.setLevel(logging.Debug)設置級別,固然，也能夠經過fh.setLevel(logging.Debug)單對文件流設置某個級別。

　　封裝到函數裏

import logging
def my_logger(filename,file=True,stream = True):
    logger = logging.getLogger()
    formatter = logging.Formatter(fmt='%(name)s %(asctime)s [%(lineno)d] --  %(message)s',
                                  datefmt='%d/%m/%y %H:%M:%S')
    logger.setLevel(logging.DEBUG) #指定日誌打印的等級
    if file:
        file_handler = logging.FileHandler(filename,encoding='utf-8')
        file_handler.setFormatter(formatter)  # 文件流 文件操做符
        logger.addHandler(file_handler)
    if stream:
        stream_handler = logging.StreamHandler()
        stream_handler.setFormatter(formatter) #屏幕流 屏幕操做符
        logger.addHandler(stream_handler)
    return logger
logger = my_logger('logging',file=False)
logger.warning("出錯了")