各類別模組的粗略總結(time,re,os,sys,序列化,pickle,shelve.#!json )

標籤：需要   for   類型   collect   not   記憶體   日期   code   資料類型轉換   

 

***collections 擴充資料類型***

***re 正則相關操作 正則 匹配字串***

***time 時間相關 三種格式:時間戳記,格式化時間(字串),時間元組(結構化時間).
***
```python
#時間戳記: timestamp 從1970年1月1日00:00開始按秒計算位移量.
time.time()

#格式化時間: (Format String) 1992-12-10
%Y-%m-%d_%a %H:%M:S
%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 當前時區的名稱
%% %號本身

#時間元組: (結構化時間)Stack_Time 包含九個元素:年 月 日 時 分 秒 今年第幾周 今年的第幾天 夏令時
```
```
#時間戳記-->時間元組(結構化時間)
time.gmtime(#填時間戳記) #UTC時間
time.localtime(#填時間戳記) #當地時間

#時間元組-->時間戳記
time.mktime(#時間元組)

#時間元組-->字串
time.strftime(‘格式定義‘,‘時間元組‘) #若不傳參數,則顯示目前時間
time.strftime("%Y-%m-%d",time.localtime(1500000000))
‘2017-07-14‘

import time
#字串-->時間元組
#time.strptime(‘時間字串‘,‘字串格式‘)
l = time.strptime(‘1992-10-10‘,‘%Y-%m-%d‘)
print(l)
#時間元組-->字串
# time.strftime(‘格式定義‘,‘時間元組‘) #若不傳時間元組,就顯示目前時間.
l1 = time.strftime(‘%Y-%m-%d‘)
print(l1)

l2 = time.strftime(‘%Y-%m-%d‘,time.localtime(1500000000))
print(l2)

 

```

***os 和作業系統有關的***

 

 

***sys 和 python 解譯器互動的***

 

 

***序列化模組 將python 中的資料結構轉化成 str.
什麼叫序列化? 將原本的字典/列表等內容,轉化成一個字串的過程***

***json json 通用的資料結構 在 python 裡表現的是字典和列表***

## json :four_leaf_clover:

用於字串和python資料類型之間進行轉換 , 因為json表示出來就是一個字串

json模組提供了四個方法

| 方法 | 描述 |
| ----- | ----------------------------- |
| dump | 接收一個檔案控制代碼 , 將原資料類型轉換成字串寫入檔案 |
| load | 接收一個檔案控制代碼 , 將檔案中的字串轉換成原資料類型返回 |
| dumps | 接收一個資料類型 , 將其轉換成字串 |
| loads | 接收一個字串 , 將其轉換成原資料類型 |

dump 和 load 執行個體

```python
# 匯入json模組
import json
# 建立一個檔案控制代碼
f = open(‘json_file‘,‘w‘)
# 建立一個字典
dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘}
# 將字典轉換成字串寫入檔案
json.dump(dic,f)
# 關閉檔案
f.close()
# 建立一個檔案控制代碼
f = open(‘json_file‘)
# 將檔案中的字串讀出並轉換成原資料類型
dic2 = json.load(f)
# 關閉檔案控制代碼
f.close()
# 列印類型和結果
print(type(dic2),dic2)
# <class ‘dict‘> {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘}
```

dumps 和 loads 執行個體

```python
# 匯入json模組
import json
# 建立一個新列表
lst = [‘1‘,‘2‘,‘3‘,‘4‘]
# 將列錶轉換成字串,用j_d來接收傳回值
j_d = json.dumps(lst)
# 將字串轉換成原資料類型,用j_s來接收傳回值
j_s = json.loads(j_d)
# 列印j_d的值以及類型
print(j_d,type(j_d))
# ["1", "2", "3", "4"] <class ‘str‘>
# 列印j_s的值以及類型
print(j_s,type(j_s))
# [‘1‘, ‘2‘, ‘3‘, ‘4‘] <class ‘list‘>
```

loads的特殊情況

```python
# 匯入json模組
import json
# 建立一個字串,內部為一個字典
dic_s = "{‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:3}"
# 將字串轉換成字典
json.loads(dic_s)
# 解譯器出現報錯
# json.decoder.JSONDecodeError: Expecting property name enclosed in double quotes: line 1 column 2 (char 1)
‘‘‘
報錯原因,用json的loads功能時,字串類型的字典中的字串必須由 "" 表示
即上面的dic_s應該改為 ‘{"k1":"v1","k2":"v2","k3":3}‘

結論:用json的loads功能時,字串類型的字典中的字串必須由 "" 表示
‘‘‘
```

PS : json可用於不同語言之間的資料交換

 

 

***pickle 在 python 裡專用的,可以對任何資料類型做序列化,結果是 bytes 類型***

***shelve 只提供一個 open 方法,操作有點像字典.***

 

 

 ## pickle :four_leaf_clover:

用於python特有的類型和python的資料類型間進行轉換

pickle模組也提供了四個方法 , 與json一樣 dumps , dump , loads , load

由於pickle是對於python特有的類型 , 所以 load 和 loads方法不僅支援字典 , 列表 , 它還能把python中任意的資料類型進行序列化

```python
-------dumps和loads--------
# 匯入pickle模組
import pickle
# 建立一個字典
dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘}
# 將字典轉換成二進位內容
p_d = pickle.dumps(dic)
# 將二進位內容轉換成字典
p_l = pickle.loads(p_d)
# 列印p_d
print(p_d)
# b‘\x80\x03}q\x00(X\x02\x00\x00\x00k2q\x01X\x02\x00\x00\x00v2q\x02X\x02\x00\x00\x00k1q\x03X\x02\x00\x00\x00v1q\x04u.‘
# 列印p_d的類型
print(type(p_d))
# <class ‘bytes‘>
# 列印p_l
print(p_l)
# {‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘}
# 列印p_l的類型
print(type(p_l))
# <class ‘dict‘>
---------dump 和 load---------
# 建立一個檔案控制代碼
f = open(‘pickle_file‘,‘wb‘)
# 寫入內容
pickle.dump(‘lyon‘,f)
# 關閉檔案
f.close()
# 建立一個檔案控制代碼
f = open(‘pickle_file‘,‘rb‘)
# 讀出內容
p_f = pickle.load(f)
# 關閉檔案
f.close()
# 列印
print(p_f)
# lyon
```

**但是pickle僅僅只能對python中的資料進行序列化 , 還原序列化時其他語言就無法讀懂了這是什麼了** , 所以我們一般用推薦使用json

 

## shelve :four_leaf_clover:

shelve也是python提供給我們的序列化工具 , 比pickle用起來簡單一些

shelve只提供給我們一個open方法 , 是用key來訪問的 , 使用起來和字典類似

```python
# 匯入shelve模組
import shelve
# shelve提供open方法
f = shelve.open(‘shelve_file‘)
# 直接對檔案控制代碼進行操作,就可以寫入檔案中
f[‘key‘] = {‘int‘:10, ‘float‘:9.5, ‘string‘:‘Sample data‘}
# 關閉檔案
f.close()
# 開啟檔案
f1 = shelve.open(‘shelve_file‘)
# 直接用key取值,key不存在就報錯
existing = f1[‘key‘]
# 關閉檔案
f1.close()
# 列印結果
print(existing)
# {‘float‘: 9.5, ‘int‘: 10, ‘string‘: ‘Sample data‘}
```

shelve不支援多個應用同時往一個資料庫進行操作 , 所以當我們知道我們的應用如果只進行操作 , 我們可以設定shelve.open() 方法的參數來進行

shelve.open(filename, flag=‘c‘, protocol=None, writeback=False)

```python
import shelve
# flag參數為設定作業模式,r 設定唯讀模式
f = shelve.open(‘shelve_file‘, flag=‘r‘)
existing = f[‘key‘]
f.close()
print(existing)
```

` writeback `參數 , 可以減少我們出錯的機率 , 並且讓對象的持久化對使用者更加的透明了 ; 但這種方式並不是所有的情況下都需要 , 首先 , 使用writeback以後 , shelf在open()的時候會增加額外的記憶體消耗 , 並且當資料庫在close()的時候會將緩衝中的每一個對象都寫入到資料庫 , 這也會帶來額外的等待時間 , 因為shelve沒有辦法知道緩衝中哪些對象修改了 , 哪些對象沒有修改 , 因此所有的對象都會被寫入

```python
import shelve
f1 = shelve.open(‘shelve_file‘)
print(f1[‘key‘])
f1[‘key‘][‘new_value‘] = ‘this was not here before‘
f1.close()
# 設定writeback
f2 = shelve.open(‘shelve_file‘, writeback=True)
print(f2[‘key‘])
f2[‘key‘][‘new_value‘] = ‘this was not here before‘
f2.close()
```

各類別模組的粗略總結(time,re,os,sys,序列化,pickle,shelve.#!json )