一、time模塊

表示時間的三種方式：

　　時間戳：數字（計算機能認識的）

　　時間字符串：t=‘2012-12-12‘

　　結構化時間：time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=8, tm_min=4, tm_sec=32, tm_wday=1, tm_yday=220, tm_isdst=0)像這樣的就是結構化時間

#time模塊的常用方法及三種時間之間的轉換
import time
# 對象：對象.方法
# ----------------------------------
# 1.時間戳(數字)：給計算機的看的
print(time.time())#當前時間的時間戳
print(time.localtime())#結構化時間對象
s=time.localtime() #當前的結構化時間對象（utc時間）
print(s.tm_year)
s2=time.gmtime()  #這個和localtime只是小時不一樣
print(s2)


#-----------------------------------
# 2.時間的轉換
print(time.localtime(15648461))#把時間戳轉換成結構化時間
t=‘2012-12-12‘ #這是一個字符串時間
print(time.mktime(time.localtime()))#將結構化時間轉換成時間戳
print(time.strftime("%Y-%m-%d",time.localtime()))#將結構化時間轉換成字符串時間
print(time.strftime(‘%y/%m/%d  %H:%M:%S‘))#小寫的y是取得年的後兩位
print(time.strptime(‘2008-03-12‘,"%Y-%m-%d"))#將字符串時間轉換成結構化時間

#python中時間日期格式化符號：
%y 兩位數的年份表示（00-99）
%Y 四位數的年份表示（000-9999）
%m 月份（01-12）
%d 月內中的一天（0-31）
%H 24小時制小時數（0-23）
%I 12小時制小時數（01-12）
%M 分鐘數（00=59）
%S 秒（00-59）
%a 本地簡化星期名稱
%A 本地完整星期名稱
%b 本地簡化的月份名稱
%B 本地完整的月份名稱
%c 本地相應的日期表示和時間表示
%j 年內的一天（001-366）
%p 本地A.M.或P.M.的等價符
%U 一年中的星期數（00-53）星期天為星期的開始
%w 星期（0-6），星期天為星期的開始
%W 一年中的星期數（00-53）星期一為星期的開始
%x 本地相應的日期表示
%X 本地相應的時間表示
%Z 當前時區的名稱
%% %號本身

time.strftime(‘格式定義‘，‘結構化時間’) 結構化時間參數若不傳，則顯示當前時間

print(time.strptime(‘2008-03-12‘,"%Y-%m-%d"))
print(time.strftime(‘%Y-%m-%d‘))
print(time.strftime("%Y-%m-%d",time.localtime(15444)))

asctime和ctime方法

print(time.asctime(time.localtime(150000)))
print(time.asctime(time.localtime()))
# time.ctime（時間戳）如果不傳參數，直接返回當前時間的格式化字符串
print(time.ctime())
print(time.ctime(150000))

二、random模塊

# random的方法
import random
# ----------------------------
# 1.隨機小數
print(random.random()) #大於0且小於1之間的隨機小數
print(random.uniform(1,3))  #大於1且小於3的隨機小數

# ----------------------------
# 2.隨機整數
print(random.randint(1,5)) #大於1且小於等於5之間的整數
print(random.randrange(1,10,2))  #大於等於1且小於3之間的整數（且是所有的奇數）

# ----------------------------
# 3.隨機選擇一個返回
print(random.choice([1,‘23‘,[4,5]]))
# ----------------------------
# 4.隨機選擇返回多個
print(random.sample([1,‘23‘,[4,5]],2))  #列表元素任意兩個組合
# ----------------------------


# ----------------------------
# 5.打亂列表順序
item=[1,5,2,3,4]
random.shuffle(item)  #打亂次序
print(item)

# 驗證碼小例子(這個只是產生隨機的四位數字)
# 方法一、
# l=[]
# for i in range(4):
#     l.append(str(random.randint(0,9)))
# print(‘‘.join(l))
# print(l)


# 方法二
# print(random.randint(1000,9999))


# 驗證碼升級版
# 要求：首次要有數字，其次要有字母，一共四位，可以重復
# chr(65-90)#a-z
# chr(97-122)#A-Z

方法一
# num_list = list(range(10))
# new_num_l=list(map(str,num_list))#[‘0‘,‘1‘...‘9‘]
# l=[] #用來存字母
# for i in range(65,91):
#     zifu=chr(i)
#     l.append(zifu)  #[‘A‘-‘Z‘]
# new_num_l.extend(l) #要把上面的數字和下面的字母拼在一塊
# print(new_num_l)
# ret_l=[] #存生成的隨機數字或字母
# for i in range(4): #從new_num_l裏面選數字選擇四次就放到了ret_l裏面)
#     ret_l.append(random.choice(new_num_l))
# # print(ret_l)
# print(‘‘.join(ret_l)) #拼成字符串

方法二
# import random
# def myrandom():
#     new_num_l=list(map(str,range(10)))
#     l=[chr(i) for i in range(65,91)]
#     new_num_l.extend(l)
#     ret_l=[random.choice(new_num_l) for i in range(4)]
#     return ‘‘.join(ret_l)
# print(myrandom())

方法三
import random
l=list(str(range(10)))+[chr(i) for i in range(65,91)]+[chr(j) for j in range(97,122)]
print(‘‘.join(random.sample(l,4)))

三、os模塊

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.popen("bash command)  運行shell命令，獲取執行結果
os.environ  獲取系統環境變量


os.path
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的大小

註意：os.stat(‘path\filename‘) 獲取文件\目錄信息的結構說明

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）是最新的元數據更改的時間，<br>在其它系統上（如Windows）是創建時間（詳細信息參見平臺的文檔）。

四、sys模塊

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

# sys模塊
import sys
print(sys.argv) #實現從程序外部向程序傳遞參數。（在命令行裏面輸打開路徑執行）
name=sys.argv[1] #命令行參數List,第一個元素是程序的本身路徑
password = sys.argv[2]
if name==‘egon‘ and password == ‘123‘:
    print(‘繼續執行程序‘)
else:
   exit()

sys.exit()#退出程序，正常退出時exit(0)
print(sys.version)#獲取python解釋的版本信息
print(sys.maxsize)#最大能表示的數，與系統多少位有關
print(sys.path)#返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
print(sys.platform)#返回操作系統平臺名稱

五、序列化模塊

1.什麽是序列化-------將原本的字典，列表等內容轉換成一個字符串的過程就叫做序列化

2.序列化的目的

　　1.以某種存儲形式使自定義對象持久化

　　2.將對象從一個地方傳遞到另一個地方

　　3.使程序更具維護性

json

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

# dumps和loads
import json
dic={‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:‘v3‘}
print(type(dic))
str_dic = json.dumps(dic) #將字典轉換成字符串，轉換後的字典中的元素是由雙引號表示的
print(str_dic,type(str_dic))#{"k1": "v1", "k2": "v2", "k3": "v3"} <class ‘str‘>


dic2 = json.loads(str_dic)#將一個字符串轉換成字典類型
print(dic2,type(dic2))#{‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘} <class ‘dict‘>

list_dic = [1,[‘a‘,‘b‘,‘c‘],3,{‘k1‘:‘v1‘,‘k2‘:‘v2‘}]
str_dic = json.dumps(list_dic) #也可以處理嵌套的數據類型
print(type(str_dic),str_dic) #<class ‘str‘> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class ‘list‘> [1, [‘a‘, ‘b‘, ‘c‘], 3, {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘}]

# dump和load
import json
f=open(‘json_file‘,‘w‘)
dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:‘v3‘}
json.dump(dic,f)# #dump方法接收一個文件句柄，直接將字典轉換成json字符串寫入文件
f.close()

f = open(‘json_file‘)
dic2 = json.load(f)  #load方法接收一個文件句柄，直接將文件中的json字符串轉換成數據結構返回
f.close()
print(type(dic2),dic2)

pickle

json 和 pickle 模塊

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

　　pickle：用於python特有的類型和python的數據類型進行轉換

# pickle的dumps,sump和loads,load方法
# --------------------------
import pickle
# dic= {‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:‘v3‘}
# str_dic=pickle.dumps(dic)
# print(str_dic)  #打印的是bytes類型的二進制內容
#
# dic2 = pickle.loads(str_dic)
# print(dic2)  #有吧字典給轉換回來了

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
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)

shelve

shelve也是python提供給我們的序列化工具，比pickle用起來更簡單一些。
shelve只提供給我們一個open方法，是用key來訪問的，使用起來和字典類似。

# shelve模塊
import shelve
f = shelve.open(‘shelve_file‘)
f[‘key‘] = {‘int‘:10, ‘float‘:9.5, ‘string‘:‘Sample data‘}  #直接對文件句柄操作，就可以存入數據
f.close()

import shelve
f1 = shelve.open(‘shelve_file‘)
existing = f1[‘key‘]  #取出數據的時候也只需要直接用key獲取即可，但是如果key不存在會報錯
f1.close()
print(existing)

這個模塊有個限制，它不支持多個應用同一時間往同一個DB進行寫操作。所以當我們知道我們的應用如果只進行讀操作，我們可以讓shelve通過只讀方式打開DB

mport shelve
f = shelve.open(‘shelve_file‘, flag=‘r‘)
existing = f[‘key‘]
f.close()
print(existing)

由於shelve在默認情況下是不會記錄待持久化對象的任何修改的，所以我們在shelve.open()時候需要修改默認參數，否則對象的修改不會保存。　　

# 設置writeback
import shelve
f1 = shelve.open(‘shelve_file‘)
print(f1[‘key‘])
f1[‘key‘][‘new_value‘] = ‘this was not here before‘
f1.close()

f2 = shelve.open(‘shelve_file‘, writeback=True)
print(f2[‘key‘])
f2[‘key‘][‘new_value‘] = ‘this was not here before‘
f2.close()

writeback方式有優點也有缺點。優點是減少了我們出錯的概率，並且讓對象的持久化對用戶更加的透明了；但這種方式並不是所有的情況下都需要，首先，使用writeback以後，shelf在open()的時候會增加額外的內存消耗，並且當DB在close()的時候會將緩存中的每一個對象都寫入到DB，這也會帶來額外的等待時間。因為shelve沒有辦法知道緩存中哪些對象修改了，哪些對象沒有修改，因此所有的對象都會被寫入。

python全棧開發【第十篇】Python常用模塊二（時間、random、os、sys和序列化）