python模塊知識三 hashlib 加密模塊、collections、re模塊

8.hashlib 加密模塊

​ 主要用於加密和校驗

常見密文：md5,sha1,sha256,sha512

1. 只要明文相同，密文就相同
2. 只要明文不相同，密文就是不相同的
3. 不能反逆（不能解密）--md5中國破解了

最經常使用的是MD5（用於校驗），平時加密時使用sha1

'''加密
    1.指定要加密的方式
    2.將要加密的內容轉成字節
    3.合成
'''
import hashlib
md5 = hashlib.md5()#1
md5 = hashlib.sha1()
md5 = hashlib.sha256()
md5 = hashlib.sha512()

md5.update("alex123".encode("utf-8"))#2  密文與編碼方式無關，只與加密方式和明文有關
print(md5.hexdigest())#3

加鹽：

#1.固定加鹽
import hashlib
pwd = "wang123"
md5 = hashlib.md5("我去".encode("utf-8"))
md5 = hashlib.md5(b"alex07yu")
md5.update(pwd.encode("utf-8"))
print(md5.hexdigest())


#2.動態加鹽
user = input("username:")
pwd = input("passwd:")
md5 = hashlib.md5(user.encode("utf-8"))
md5.update(pwd.encode("utf-8"))
print(md5.hexigest())

#3.讀取文件內容加密
f = open(r"F:\s24\day17\python-3.6.6-amd64.exe",'rb')
md5 = hashlib.md5()
md5.update(f.read())
print(md5.hexdigest())

#4.逐步加密和一次加密結果同樣
import hashlib
pwd1 = 'a'
pwd2 = 'b'
pwd3 = 'ab'
md5 = hashlib.md5()
md5.update(pwd1.encode("utf-8"))
md5.update(pwd2.encode("utf-8"))
print(md5.hexdigest())
md6 = hashlib.md5()
md6.update(pwd3.encode("utf-8"))

#5.接3，當文件太大時，逐步加密，節省內存
import hashlib
f = open(f"F:\s24\day17\python-3.6.6-amd64.exe",'rb')
md5 = hashlib.md5()
while 1:
    msg = f.read(1024)#每次讀取1024字節
    if msg:
        md5.update(msg)
    else:
        print(md5.hexdigest())
        break

9.collections

1. namedtuple :命名元組。生成能夠使用的名字來訪問元素內容的tuple
2. deque:雙端隊列，能夠快速地從另外一側追加和刪除對象
3. Counter:計數器，用來計算重複的元素個數
4. defaultdict:帶有默認值的字典
5. OrdereDict

from collections import namedtuple
#1.
point = namedtuple('a',['x','y'])
p = point(1,2)
print(p)
#2.
from collections import deque
lst1 = depue([1,2,3,4,5])
lst1.append(8)
lst1.appendleft(0)
lst1.pop()
lst1.popleft()
print(lst1[4])
#3.***
from collections import Counter
s1 = '13215af13213a1dfa3sdfa3'
print(dict(Count(s1)))
s2 = [1,1,2,2,3,3]
print(dict(Count(s2)))
s3 = (1,2,3,3,4,5,6,7,78)
print(dict(Count(s3)))
#4.
from collections import defaultdict
dic = defaultdict(list)
dic['k1'].append(1)
print(dic)
#結果：defaultdict(<class 'list'>, {'k1': [1]})
'''
將列表中大於66的放到k1中，其他的放到k2中,用帶有默認值的字典模塊作
'''
li = [11,22,33,44,55,77,88,99,90]
from collections import defaultdict
dic = defaultdict(set)
for i in li:
    if i > 60:
        dic['k1'].add(i)
    else:
        dic['k2'].add(i)
print(dic)
#5.瞭解

10.re模塊

正則：就是用一些具備特殊含義的符號組合到一塊兒（稱爲正則表達式）來描述字符或者字符串的方法。正則就是用來描述一類事物的規則

元字符	匹配規則
\w	匹配字母（包含中文）或數字或下劃線
\W	匹配除字母（包含中文），數字或下劃線
\s	匹配任意的空白符
\S	匹配任意的非空白符
\d	匹配數字，等價於[0-9]
\D	匹配非數字
\A	從字符串開頭匹配
\Z	匹配字符串結束，若是是換行，只匹配到換行前的結果
\n	匹配一個換行符
\t	匹配一個製表符
^	匹配字符串的開始
$	匹配字符串的結尾
.	匹配任意字符，除換行符，當re.DOTALL標記被指定時，則能夠匹配包括換行符的任意字符
[]	匹配字符組中的字符，[abc]表示a,b,c。[a-z]表示a到z單個字符,'-'不會匹配到，當放到開頭纔會匹配--> [-a-z]
[^]	匹配除了字符組中的字符外的全部字符，[^abc]表示非a或者b或者c的單個字符
*	前一個字符0次或無限次擴展，abc* 表示 ab、abc、abcc、abccc……
+	前一個字符1次或無限次擴展，
？	前一個字符0次或一次擴展
{n}	擴展前一個字符n次，ab{2}c表示abbc
{m,n}	匹配擴展前一個字符擴展m到n次，含n次，貪婪匹配
|	左右任意表達一個，a|b匹配a或b
()	匹配括號內的表達式，表示一個組，括號內可用|，(abc|def)表示abc或def。m(?:)t將括號內外一塊兒輸出

1.方法

1. re.search():在字符串中搜索匹配正則表達式的第一個位置，並返回math對象，.group()查看對象。

2. re.match():從字符串的開始位置匹配正則表達式，並返回match對象

   match對象沒有匹配到就返回None

import re
#search找到第一個就中止查找
print(re.search(r'[1-9]\d{3}','100086'))
print(re.search(r'[1-9]\d{3}','00086001500012').group())
#match只從開頭找，開頭不符合就不查找了
print(re.search(r'[1-9]\d{3}','100086'))
print(re.match(r'[1-9]\d{3}','00086002154'))

1. re.findall():搜索字符串，以列表的類型返回所有等匹配的子串
2. re.split():將一個字符串按照正則表達式匹配的結果進行分割，返回列表
3. re.sub():在一個字符串中替代全部匹配的正則表達式的子串，返回替代後的字符串

import re
#分割
s = 'aa#所謂結案,2123:lkj!無*所謂'
print(re.split("[#,:!*]",s))

#替換
print(re.sub("所謂","me",s))

1. re.finditer():返回的是一個迭代器地址

import re
f = re.finditer("\w","你是垃圾")
print(next(f).group())

for i in f:
    print(i)

2.re的兩種等價方法：

1. 函數式用法：一次性操做
2. 面向對象用法：編譯後可對此操做，re.compile()-->定義匹配規則

import
#1.函數式用法：
rst = re.search(r'[1-9]\d{5}','BIT 100086')
print(rst.group())
#2.面向對象：
pat = re.compile(r'[1-9]\d{5}')
rst = pst.serch('BIT 100086')

3.正則的貪婪匹配和最小匹配(默認爲貪婪匹配)

符號	匹配規則	貪婪規則
*?	前一個字符0或無限次擴展	最小匹配
+?	1或	最小匹配
？？	0或1	最小匹配
{m,n}	擴展前一個字符m-n次含n	貪婪匹配

import re
#貪婪匹配
match = re.search(r'py.*n','pyanbncndn')
print(match.group(0))
#最小匹配加'?'
match = re.search(r'py.*?n','pyanbncndn')
print(match.group(0))

4.起名字

m(? <名字> \w+)t group("名字")

import re
print(re.search("(?<ta_name>\w+)\w+",h1hellth).group("ta_name"))