萬惡之源 - Python模塊一

序列化

咱們今天學習下序列化,什麼是序列化呢? 將本來的字典、列表等內容轉換成一個字符串的過程就叫作序列化。

爲何要有序列化模塊: 好比，咱們在python代碼中計算的一個數據須要給另一段程序使用，那咱們怎麼給？ 如今咱們能想到的方法就是存在文件裏，而後另外一個python程序再從文件裏讀出來。 可是咱們都知道，對於文件來講是沒有字典這個概念的，因此咱們只能將數據轉換成字典放到文件中。 你必定會問，將字典轉換成一個字符串很簡單，就是str(dic)就能夠辦到了，爲何咱們還要學習序列化模塊呢？ 沒錯序列化的過程就是從dic 變成str(dic)的過程。如今你能夠經過str(dic)，將一個名爲dic的字典轉換成一個字符串， 可是你要怎麼把一個字符串轉換成字典呢？ 聰明的你確定想到了eval()，若是咱們將一個字符串類型的字典str_dic傳給eval，就會獲得一個返回的字典類型了。 eval()函數十分強大，可是eval是作什麼的？e官方demo解釋爲：將字符串str當成有效的表達式來求值並返回計算結果。 ＢＵＴ！強大的函數有代價。安全性是其最大的缺點。 想象一下，若是咱們從文件中讀出的不是一個數據結構，而是一句"刪除文件"相似的破壞性語句，那麼後果實在不堪設設想。 而使用eval就要擔這個風險。 因此，咱們並不推薦用eval方法來進行反序列化操做(將str轉換成python中的數據結構)

序列化的目的

一、以某種存儲形式使自定義對象持久化；
二、將對象從一個地方傳遞到另外一個地方。
三、使程序更具維護性。

json

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

dumps 及 loads

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化：將一個字典轉換成一個字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意，json轉換完的字符串類型的字典中的字符串是由""表示的
​
dic2 = json.loads(str_dic)  #反序列化：將一個字符串格式的字典轉換成一個字典
#注意，要用json的loads功能處理的字符串類型的字典中的字符串必須由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
​
​
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)　

其餘參數說明

Serialize obj to a JSON formatted str.(字符串表示的json對象) 
Skipkeys：默認值是False，若是dict的keys內的數據不是python的基本類型(str,unicode,int,long,float,bool,None)，設置爲False時，就會報TypeError的錯誤。此時設置成True，則會跳過這類key 
ensure_ascii:，當它爲True的時候，全部非ASCII碼字符顯示爲\uXXXX序列，只需在dump時將ensure_ascii設置爲False便可，此時存入json的中文便可正常顯示。) 
If check_circular is false, then the circular reference check for container types will be skipped and a circular reference will result in an OverflowError (or worse). 
If allow_nan is false, then it will be a ValueError to serialize out of range float values (nan, inf, -inf) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (NaN, Infinity, -Infinity). 
indent：應該是一個非負的整型，若是是0就是頂格分行顯示，若是爲空就是一行最緊湊顯示，不然會換行且按照indent的數值顯示前面的空白分行顯示，這樣打印出來的json數據也叫pretty-printed json 
separators：分隔符，其實是(item_separator, dict_separator)的一個元組，默認的就是(‘,’,’:’)；這表示dictionary內keys之間用「,」隔開，而KEY和value之間用「：」隔開。 
default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. 
sort_keys：將數據根據keys的值進行排序。 
To use a custom JSONEncoder subclass (e.g. one that overrides the .default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.

參數說明

 

json格式化輸出

import json
data = {'username':['李華','二愣子'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
print(json_dic2)

pickle模塊

用於序列化的兩個模塊

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

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二進制內容
​
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_time2.tm_year)

這時候機智的你又要說了，既然pickle如此強大，爲何還要學json呢？ 這裏咱們要說明一下，json是一種全部的語言均可以識別的數據結構。 若是咱們將一個字典或者序列化成了一個json存在文件裏，那麼java代碼或者js代碼也能夠拿來用。 可是若是咱們用pickle進行序列化，其餘語言就不能讀懂這是什麼了～ 因此，若是你序列化的內容是列表或者字典，咱們很是推薦你使用json模塊 但若是出於某種緣由你不得不序列化其餘的數據類型，而將來你還會用python對這個數據進行反序列化的話，那麼就可使用pickle

總結:

json模塊裏的dumps是將python的數據結構轉換成字符串,loads是將字符串類型轉換成python的數據結構
​
    json模塊裏的dump是將python的數據結構轉換成字符串,而後存入到文件當中
​
    json模塊裏的load是將文件中字符串類型轉換成python的數據結構
​
    pickle模塊裏的dumps是將python的數據結構轉換成二進制的文件,loads是將二進制的文件轉換成python的
​
        數據結構
​
    pickle模塊裏的dump是將python的數據結構轉換成二進制而後存入到文件中
​
    pickle模塊裏的load是將文件中的二進制文件轉成python的數據結構

random 模塊

random是一個隨機數模塊,咱們通常用來生成一些沒有規則的內容

獲取0-1之間的隨機小數

import random
print(random.random())

咱們能夠獲取0到1之間的隨機的小數,可是還可以知足你,你想要生成指定的數字內的隨機小數怎麼辦??

import random
print(random.uniform(1,5))

這樣寫完後,你就有又想法了,說小數你實現了.整數怎麼作到隨機呢?老鐵別急

import random
print(random.randint(1,5))

你這樣是實現了,我想讓你給生成隨機的奇數和偶數,怎麼樣不會了吧??

import random
print(random.randrange(1,5,2))   #隨機生成1-5的奇數
print(random.randrange(0,5,2))   #隨機生成0-5的偶數

我還真發現了,真有點難不住你了,我如今有一個列表 lst = ['張開','寶元','佩奇','太白'],你給我隨機抽一我的出來

import random
lst = ['張開','寶元','佩奇','太白']
print(random.choice(lst))

看來仍是有兩把刷子的,我在考考你.怎麼給我隨機抽出兩個來　　

import random
lst = ['張開','寶元','佩奇','太白']
print(random.choices(lst,k=2))

差點就被你騙你了,要不是我眼疾手快,發現了你隨機出來的兩個內容是有重複的,我還就要誇你了,沒有知足需求從新實現

import random
lst = ['張開','寶元','佩奇','太白']
print(random.sample(lst,k=2))

能夠啊,真是少年有爲啊,難不住了,看來事要逼着我使用絕招了.我給你一個列表你給我讓他變成隨機排序的

import random
lst = [1,2,3,4,5,6]
random.shuffle(lst)
print(lst)

看來仍是真是不簡單啊.老衲服了!

os模塊

os模塊是與操做系統交互的一個接口​

#和文件夾相關
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下爲"\r\n",Linux下爲"\n"
os.pathsep    輸出用於分割文件路徑的字符串 win下爲;,Linux下爲:
os.name    輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'
​
# 和執行系統命令相關
os.system("bash command")  運行shell命令，直接顯示
os.popen("bash command).read()  運行shell命令，獲取執行結果
os.environ  獲取系統環境變量
​
#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.getcwd() 獲取當前工做目錄，即當前python腳本工做的目錄路徑
os.chdir("dirname")  改變當前腳本工做目錄；至關於shell下cd
os.curdir  返回當前目錄: ('.')
os.pardir  獲取當前目錄的父目錄字符串名：('..')

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

sys模塊

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

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

hashlib模塊

算法介紹 Python的hashlib提供了常見的摘要算法，如MD5，SHA1等等。

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

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

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

咱們以常見的摘要算法MD5爲例，計算出一個字符串的MD5值：

import hashlib

md5 = hashlib.md5()
md5.update('how'.encode('utf-8'))
print(md5.hexdigest())

結果:db88a0257c220dbfdd2e40f6152d6a8d

若是數據量很大，能夠分塊屢次調用update()，最後計算的結果是同樣的：

import hashlib
md5 = hashlib.md5()
md5.update('how你好啊,我很差'.encode('utf-8'))
print(md5.hexdigest())
結果:3bfa4bfb7b59a59f27c24ebdd89cd13c


import hashlib
md5 = hashlib.md5()
md5.update('how'.encode('utf-8'))
md5.update('你好啊,我很差'.encode('utf-8'))
print(md5.hexdigest())
結果:3bfa4bfb7b59a59f27c24ebdd89cd13c

MD5是最多見的摘要算法，速度很快，生成結果是固定的128 bit字節，一般用一個32位的16進制字符串表示。另外一種常見的摘要算法是SHA1，調用SHA1和調用MD5徹底相似：

import hashlib

sha1 = hashlib.sha1()
sha1.update('how to use sha1 in'.encode('utf-8'))
sha1.update('python hashlib?'.encode('utf-8'))
print(sha1.hexdigest())

結果:86e1eae2a08c152d39b55baed085c71a0cc9d10b

SHA1的結果是160 bit字節，一般用一個40位的16進制字符串表示。

SHA1的安全係數比MD5還要高一些,並且摘要的長度要比MD5長一些.

比SHA1更安全的算法是SHA256和SHA512，不過越安全的算法越慢，並且摘要長度更長。

摘要算法應用 任何容許用戶登陸的網站都會存儲用戶登陸的用戶名和口令。如何存儲用戶名和口令呢？方法是存到數據庫表中：

name    | password
--------+----------
michael | 123456
bob     | abc999
alice   | alice2008

若是以明文保存用戶口令，數據庫泄露，全部用戶的口令就落入黑客的手裏就......

此外，網站運維人員是能夠訪問數據庫的，也就是能獲取到全部用戶的口令。正確的保存口令的方式是不存儲用戶的明文口令，而是存儲用戶口令的摘要，好比MD5：

username | password
---------+---------------------------------
michael  | e10adc3949ba59abbe56e057f20f883e
bob      | 878ef96e86145580c38c87f0410ad153
alice    | 99b1c2188db85afee403b1536010c2c9

考慮這麼個狀況，不少用戶喜歡用123456，888888，password這些簡單的口令，因而，黑客能夠事先計算出這些經常使用口令的MD5值，獲得一個反推表：

'e10adc3949ba59abbe56e057f20f883e': '123456'
'21218cca77804d2ba1922c33e0151105': '888888'
'5f4dcc3b5aa765d61d8327deb882cf99': 'password'

這樣，無需破解，只須要對比數據庫的MD5，黑客就得到了使用經常使用口令的用戶帳號。

對於用戶來說，固然不要使用過於簡單的口令。可是，咱們可否在程序設計上對簡單口令增強保護呢？

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

import hashlib
md5 = hashlib.md5('salt'.encode('utf-8'))  #這是加鹽了的
md5.update('how你好啊,我很差'.encode('utf-8'))
print(md5.hexdigest())  
#結果 49f3d086ef5582b12d294c6f1b1c9dea


import hashlib
md5 = hashlib.md5()
md5.update('how你好啊,我很差'.encode('utf-8'))
print(md5.hexdigest())  
#結果 3bfa4bfb7b59a59f27c24ebdd89cd13c

通過Salt處理的MD5口令，只要Salt不被黑客知道，即便用戶輸入簡單口令，也很難經過MD5反推明文口令。

可是若是有兩個用戶都使用了相同的簡單口令好比123456，在數據庫中，將存儲兩條相同的MD5值，這說明這兩個用戶的口令是同樣的。有沒有辦法讓使用相同口令的用戶存儲不一樣的MD5呢？

若是假定用戶沒法修改登陸名，就能夠經過把登陸名做爲Salt的一部分來計算MD5，從而實現相同口令的用戶也存儲不一樣的MD5。

摘要算法在不少地方都有普遍的應用。要注意摘要算法不是加密算法，不能用於加密（由於沒法經過摘要反推明文），只能用於防篡改，可是它的單向計算特性決定了能夠在不存儲明文口令的狀況下驗證用戶口令。

collections模塊

在內置數據類型（dict、list、set、tuple）的基礎上，collections模塊還提供了幾個額外的數據類型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1.namedtuple: 生成可使用名字來訪問元素內容的tuple

2.deque: 雙端隊列，能夠快速的從另一側追加和推出對象

3.Counter: 計數器，主要用來計數

4.OrderedDict: 有序字典

5.defaultdict: 帶有默認值的字典

namedtuple

咱們知道tuple能夠表示不變集合，例如，一個點的二維座標就能夠表示成：

p = (1, 2)

可是，看到(1, 2)，很難看出這個tuple是用來表示一個座標的。

這時，namedtuple就派上了用場：

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2

相似的，若是要用座標和半徑表示一個圓，也能夠用namedtuple定義：

namedtuple('名稱', [屬性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])

deque

使用list存儲數據時，按索引訪問元素很快，可是插入和刪除元素就很慢了，由於list是線性存儲，數據量大的時候，插入和刪除效率很低。

deque是爲了高效實現插入和刪除操做的雙向列表，適合用於隊列和棧：

>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])

deque除了實現list的append()和pop()外，還支持appendleft()和popleft()，這樣就能夠很是高效地往頭部添加或刪除元素。

OrderedDict

使用dict時，Key是無序的。在對dict作迭代時，咱們沒法肯定Key的順序。

若是要保持Key的順序，能夠用OrderedDict：

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是無序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意，OrderedDict的Key會按照插入的順序排列，不是Key自己排序：

defaultdict

有以下值集合 [11,22,33,44,55,66,77,88,99,90...]，將全部大於 66 的值保存至字典的第一個key中，將小於 66 的值保存至第二個key的值中。

即： {'k1': 大於66 , 'k2': 小於66}

li = [11,22,33,44,55,77,88,99,90]
result = {}
for row in li:
    if row > 66:
        if 'key1' not in result:
            result['key1'] = []
        result['key1'].append(row)
    else:
        if 'key2' not in result:
            result['key2'] = []
        result['key2'].append(row)
print(result)
from collections import defaultdict
​
values = [11, 22, 33,44,55,66,77,88,99,90]
​
my_dict = defaultdict(list)
​
for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

使用dict時，若是引用的Key不存在，就會拋出KeyError。若是但願key不存在時，返回一個默認值，就能夠用defaultdict：

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默認值
'N/A'

Counter

Counter類的目的是用來跟蹤值出現的次數。它是一個無序的容器類型，以字典的鍵值對形式存儲，其中元素做爲key，其計數做爲value。計數值能夠是任意的Interger（包括0和負數）。Counter類和其餘語言的bags或multisets很類似。

c = Counter('abcdeabcdabcaba')
print c
輸出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})