常見的場景：一個模塊就是一個包含了python定義和聲明的文件，文件名就是模塊名字加上.py的後綴。

但其實import加載的模塊分為四個通用類別：　

　　1 使用python編寫的代碼（.py文件）

　　2 已被編譯為共享庫或DLL的C或C++擴展

　　3 包好一組模塊的包

　　4 使用C編寫並鏈接到python解釋器的內置模塊

為何要使用模塊？

如果你退出python解釋器然後重新進入，那麽你之前定義的函數或者變量都將丟失，因此我們通常將程序寫到文件中以便永久保存下來，需要時就通過python test.py方式去執行，此時test.py被稱為腳本script。

隨著程序的發展，功能越來越多，為了方便管理，我們通常將程序分成一個個的文件，這樣做程序的結構更清晰，方便管理。這時我們不僅僅可以把這些文件當做腳本去執行，還可以把他們當做模塊來導入到其他的模塊中，實現了功能的重復利用

序列化

什麽叫序列化——將原本的字典、列表等內容轉換成一個字符串的過程就叫做序列化。

序列化的目的

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

json模塊:

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

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‘}]

loads和dumps

dump和json方法使用：

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)

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中任意的數據類型序列化）

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)

json是一種所有的語言都可以識別的數據結構,如果我們將一個字典或者序列化成了一個json存在文件裏，那麽java代碼或者js代碼也可以拿來用.pickle 只支持python

小結：
　　son模塊裏的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())

想要生成指定的數字內的隨機小數怎麽辦??

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)

課堂示例：

# 隨機數
import random  # 內置的
# print(random.random())
# 0-1 之間隨機小數

# print(random.randint(1,10))
# 起始位置,終止位置 兩頭都包含

# print(random.randrange(1,21,2))
# 起始位置,終止位置(不包含),步長

# print(random.choice([‘alex‘,‘wusir‘,‘eva_j‘]))
# 從有序數據結構中隨機選擇一個

# print(random.choices([‘wusir‘,‘tialaing‘,‘taihei‘,‘ritian‘],k=2))
# 隨機選擇兩個,但是有重復

# print(random.sample([‘wusir‘,‘tialaing‘,‘taihei‘,‘ritian‘],k=2))
# 隨機選擇兩個,沒有重復

# li = [1,2,3,4,6]
# random.shuffle(li)  # 洗牌 打亂順序
# print(li)

# 隨機數  驗證碼  微信紅包

# print(chr(65),chr(90),chr(97),chr(122))

# U = chr(random.randrange(65,91))
# L = chr(random.randrange(97,123))
# n1 = random.randrange(0,10)
# n2 = random.randrange(0,10)
# print(U, L,n1,n2)

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的大小<br></em>


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）是創建時間（詳細信息參見平臺的文檔）。　

課堂整體講解，著重點：

# 1.os模塊和當前電腦操作系統做交互
# os 內置模塊

# 文件夾:
import os
# os.makedirs(‘app/a/b/c‘)   # 遞歸創建文件       ***
# os.removedirs(‘app/a/b/c‘) # 遞歸刪除文件, 當這個要刪除的目錄有文件就停止刪除  ***
# os.mkdir(‘app‘)   # 創建單個目錄                ***
# os.rmdir(‘app‘)     # 刪除單個目錄,目錄如果有東西就報錯不進行刪除    ***
# print(os.listdir(‘D:\PyCharmProject\s20\day14‘))    ****
# 查看某個目錄下的內容

# 文件:
# os.remove() #刪除這個文件,刪除了就不能恢復了    *****
# os.rename()   #修改文件的名字                  *****

# 操作系統:
# print(repr(os.sep))  #\\
# C:\Users\lucky\Documents\Tencent Files\932023756\FileRecv
# 路徑符號

# print(repr(os.linesep))
# 換行符

# print(repr(os.pathsep))
# 環境變量的分割

# print(repr(os.name))

# print(os.system(‘dir‘))

# print(os.popen(‘dir‘).read())               ***
# 在寫程序的時候可以下發一些操作系統的指令
# 在linux系統上相當於發shell命令

# print(os.environ) 查看 高級 -- 環境變量 -- path   *

# 路徑:
# print(os.path.abspath(‘b‘))      ****
# 獲取當前文件的絕對路徑
# print(os.path.split(r‘D:\PyCharmProject\s20\day14\b‘))
# 將這個文件的絕對路徑分成目錄和文件
# print(os.path.basename(r‘D:\PyCharmProject\s20\day14\b‘))  **
# 獲取的是這個文件的名字
# print(os.path.dirname(r‘D:\PyCharmProject\s20\day14\b‘))   ***
# 獲取的是這個文件的目錄路徑
# print(os.path.exists(r‘D:\PyCharmProject\s20\day10\07 今日總結.py‘)) **
# 判斷這個文件是否存在
# print(os.path.isabs(r‘D:\PyCharmProject\s20\day14\b‘))
# 判斷是否是絕對路徑

# print(os.path.join(‘C:\\‘,‘app‘,‘a‘,‘b‘))                 *****
# #路徑拼接的  軟件開發規範 框架

# os.stat()

# print(os.stat(‘b‘).st_size)   #獲取文件大小 ,坑目錄        ***
# print(os.getcwd())  # 獲取工作路勁                         ***

# os.chdir(‘D:\PyCharmProject\s20\day13‘)  # 路勁切換        *
# print(os.getcwd())

sys模塊

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

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

著重點：

# 1. sys模塊 python解釋器交互的

# sys 內置的

import sys

# print(sys.argv[-1])       ***
# 接受cmd方式調用 後邊的參數會傳遞進來
# linux系統上  -- 後端開發 -- 數據庫(文件) ip + 端口

# print(sys.path)   # 添加自定義模塊路徑的                 # ******

# print(sys.version)  # 版本  獲取解釋的版本號

# sys.platform = ‘win1988‘

# print(sys.platform)   #獲取當前操作系統的平臺位數          # 不是定死的

# print(sys.exit(1))

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，不過越安全的算法越慢，而且摘要長度更長。

網站運維人員是可以訪問數據庫的，也就是能獲取到所有用戶的口令。正確的保存口令的方式是不存儲用戶的明文口令，而是存儲用戶口令的摘要，比如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。

摘要算法在很多地方都有廣泛的應用。要註意摘要算法不是加密算法，不能用於加密（因為無法通過摘要反推明文），只能用於防篡改，但是它的單向計算特性決定了可以在不存儲明文口令的情況下驗證用戶口令。

課堂實例：

# 1.# 加密算法
# 作用: 當做密碼
# 判斷一致性
# 2.加密後不可逆 不能解 (一年前暴力破解 -- 撞庫)
# (現在md5 反推)

# 3.sha1,sha256,sha512

# alex3714
# **********

# import hashlib
# md5 = hashlib.md5(‘鹽‘.encode(‘utf-8‘))  # 選擇加密方式  加鹽
# md5.update(‘alex3714‘.encode(‘utf-8‘)) # 將明文轉成字節然後進行加密
# print(md5.hexdigest()) # 生成密文

# md5 = hashlib.md5()  # 選擇加密方式  加鹽
# md5.update(‘alex3714‘.encode(‘utf-8‘)) # 將明文轉成字節然後進行加密
# print(md5.hexdigest()) # 生成密文

# sha512 = hashlib.sha512()
# sha512.update(‘alex3714‘.encode(‘utf-8‘))
# print(sha512.hexdigest())


# # sha512
# 優點:
#     安全
# 缺點:
#     慢
#
# # md5
# 優點:
#     安全,快
# 缺點:
#     容易破解


# user,pwd = input(‘user|pwd:‘).strip().split(‘|‘)
# import hashlib
#
# md5 = hashlib.md5(str(user).encode(‘utf-8‘))
# md5.update(pwd.encode(‘utf-8‘))
# print(md5.hexdigest())

# md5,sha1,sha256,sha512

shelve模塊

課堂示例：

# 序列化:
# 1.文件 + 字典操作

# import shelve
# f = shelve.open(‘c‘,writeback=True)  #創建文件  # writeback = True 回寫

# f[‘name‘] = ‘alex‘
#
# f[‘age‘] = 18
#
# print(f[‘name‘],f[‘age‘])

# f[‘name‘] = [‘alex‘,‘wusir‘]
#
# print(f[‘name‘])

# print(f)  # 這樣是查看不了字典

# for i in f:
#     print(i)   #獲取到所有的鍵

# print(f.keys())  #keys也不行

# for i in f:
#     print(f[i])

# dump load   咱們不用寫,自動幫咱們寫的

# f[‘name‘] = {‘2‘:4}

# print(f[‘name‘])

# for i in f:
#     print(i)

# 註意:以後你們會出現一個問題,咱們對字典的操作內容,有時候寫不進去.在open

# print(f[‘name‘])

# f[‘name‘] = ‘wusir‘
# print(f[‘name‘])   # {‘2‘:4}

# f[‘name‘] = [1,2,34]

# print(list(f.keys()))


# json 最常用,前後端分離的時候數據交互  前後端分離  必回
# pickle python 不怎麽常用   河南方言             必了解
# shelve 建議使用它,它簡單   重慶,東北,容易學      必了解

今日總結：

# 1.序列化
#     json   # 必會

            # dump   把字典轉成字符串存入文件
            # load   將文件的字符串轉成字典
            # dumps  將字典轉成字符串
            # loads  將字符串轉成字典

#     pickle # 了解
#     shevle # 了解

# 2. 隨機數
#     random.random()  0-1 之間的小數
#     驗證碼
#     random.randint(1,10)

# 3. os 操作系統

#     路徑部分
#     os.path.join
#     os.path.abspath
#     os.path.basename
#     os.path.dirname
#     os.path.getsize()  # 獲取大小
#     os.remove()
#     os.rename()
#     os.listdir()
#     os.chdir()  # 切換目錄
#     os.makedirs(‘app/a/b‘) 遞歸創建文件夾
#     os.removedirs(‘app/a/b‘)  遞歸刪除
#     os.mkdir()  創建單個文件夾
#     os.rmdir()  刪除單個文件夾

# sys python解釋器

# sys.argv()  在cmd中執行 可以將文件 後的內容傳遞到文件中使用
# sys.path    python解釋器加載的路徑,自定義模塊添加到這裏
# sys.exit()
# sys.version()  獲取解釋器的版本號
# sys.platform   獲取當前平臺的位數


# hashlib 加密算法
# md5,sha1,sha256,sha512
# 1.先導入模塊
# 2.創建一個加密方式
# 3.將要加密的內容編碼成字節後加密
# 4.生成密文

# import hashlib
# md5 = hashlib.md5(b‘alex‘)
# md5.update(‘alex3714‘.encode(‘utf-8‘))
# print(md5.hexdigest())

Python入門基礎知識點（模塊）