hashhlib 模块
什么叫hash：hash是一种算法，该算法接受传入的内容，经过运算得到一串hash值
2，hash的特征
（1）只要传人的内容一样，得到的1hash值一样=====》要用明文传输密码文件完整性校验
（2）不能由hash值反解成内容====》把密码做成hash值，不应该在网络传输明文密码
（3）只要使用的hash算法不变，无论校验的内容有多大，得到的hash值长度是固定的
 import hashlib
 
m=hashlib.md5()# m=hashlib.sha256()
 
 m.update('hello'.encode('utf8'))
 print(m.hexdigest())  #5d41402abc4b2a76b9719d911017c592
 
 m.update('alvin'.encode('utf8'))
 
 print(m.hexdigest())  #92a7e713c30abbb0319fa07da2a5c4af
 
 m2=hashlib.md5()
 m2.update('helloalvin'.encode('utf8'))
 print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af
 
 '''
 注意：把一段很长的数据update多次，与一次update这段长数据，得到的结果一样
 但是update多次为校验大文件提供了可能。
 '''

上面算法虽然很联合，但是存在缺陷，通过撞库可以反解
import hashlib
所以我们要密码加盐来提高安全性
m=hashlib.md5()
m.update(‘天王盖地虎’.encode（‘utf-8’）)
m.update(pwd.encode('utf-8'))
m.update('gdhgfhjhdj'.encode('utf-8'))
print('m.hexdigest()')

import hashlib
passwds=[
    'alex3714',
    'alex1313',
    'alex94139413',
    'alex123456',
    '123456alex',
    'a123lex',
    ]
def make_passwd_dic(passwds):
    dic={}
    for passwd in passwds:
        m=hashlib.md5()
        m.update(passwd.encode('utf-8'))
        dic[passwd]=m.hexdigest()
    return dic

def break_code(cryptograph,passwd_dic):
    for k,v in passwd_dic.items():
        if v == cryptograph:
            print('密码是===>\033[46m%s\033[0m' %k)

cryptograph='aee949757a2e698417463d47acac93df'
break_code(cryptograph,make_passwd_dic(passwds))

python 还有一个 hmac 模块，它内部对我们创建 key 和 内容 进行进一步的处理然后再加密:
1 import hmac
2 h = hmac.new('alvin'.encode('utf8'))
3 h.update('hello'.encode('utf8'))
4 print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940

#要想保证hmac最终结果一致，必须保证：
#1:hmac.new括号内指定的初始key一样
#2:无论update多少次，校验的内容累加到一起是一样的内容

import hmac

h1=hmac.new(b'egon')
h1.update(b'hello')
h1.update(b'world')
print(h1.hexdigest())

h2=hmac.new(b'egon')
h2.update(b'helloworld')
print(h2.hexdigest())

h3=hmac.new(b'egonhelloworld')
print(h3.hexdigest())

'''
f1bf38d054691688f89dcd34ac3c27f2
f1bf38d054691688f89dcd34ac3c27f2
bcca84edd9eeb86f30539922b28f3981
'''

suproess模块（系统命令）
主要常用的三个
task list | findstr（过例找到）python
taskkill/？
python.exe （查看）12360 console
D：\code>taskkill /f/PID 12360 强制

configparser模块
（解析）

[section1] k1 = v1 k2:v2 user=egon age=18 is_admin=true salary=31
[section2] k1 = v1

读取

import configparser config=configparser.ConfigParser()
config.read('a.cfg')
#查看所有的标题 res=config.sections() #['section1', 'section2'] print(res)
#查看标题section1下所有key=value的key options=config.options('section1')
print(options) #['k1', 'k2', 'user', 'age', 'is_admin', 'salary']

面向对象

面向过程的程序设计：核心是过程二字，过程指的是解决问题的步骤，
即先干什么再干什么......面向过程的设计就好比精心设计好一条流水线，是一种机械式的思维方式。

类与对象

类即类别、种类，是面向对象设计最重要的概念，对象是特征与技能的结合体，
而类则是一系列对象相似的特征与技能的结合体

那么问题来了，先有的一个个具体存在的对象（比如一个具体存在的人），
还是先有的人类这个概念，这个问题需要分两种情况去看

在现实世界中：先有对象，再有类

对象1：李坦克
    特征:
        学校=oldboy
        姓名=李坦克
        性别=男
        年龄=18
    技能：
        学习
        吃饭
        睡觉

对象2：王大炮
    特征:
        学校=oldboy
        姓名=王大炮
        性别=女
        年龄=38
    技能：
        学习
        吃饭
        睡觉

现实中的老男孩学生类 相似的特征: 学校=oldboy 相似的技能： 学习 吃饭 睡觉

在程序中，务必保证，先定义类，后使用
class OldboyStudent:
school='oldboy'
 def learn(self):
 print('is learning')
 def eat(self):
 print('is eating')
 def sleep(self):
 print('is sleeping')

#注意： 1.类中可以有任意python代码，这些代码在类定义阶段便会执行
2.因而会产生新的名称空间，用来存放类的变量名与函数名，
可以通过OldboyStudent.__dict__查看
3.对于经典类来说我们可以通过该字典操作类名称空间的名字（新式类有限制），但
python为我们提供专门的.语法 4.点是访问属性的语法，类中定义的名字，都是类的属性 #程序中类的用法 .:
专门用来访问属性，本质操作的就是__dict__ OldboyStudent.school
#等于经典类的操作OldboyStudent.__dict__['school'] OldboyStudent.school='Oldboy'
 #等于经典类的操作OldboyStudent.__dict__['school']='Oldboy' OldboyStudent.x=1
#等于经典类的操作OldboyStudent.__dict__['x']=1 del OldboyStudent.x #等于经典类的操作OldboyStudent.__dict__.pop('x')
 #程序中的对象 #调用类，或称为实例化，
得到对象 s1=OldboyStudent() s2=OldboyStudent() s3=OldboyStudent()
#如此，s1、s2、s3都一样了，而这三者除了相似的属性之外还各种不同的属性，
这就用到了__init__ #注意：该方法是在对象产生之后才会执行，只用来为对象进行初始化操作，
可以有任意代码，但一定不能有返回值 class OldboyStudent: ...... def __init__(self,name,age,sex):
 self.name=name self.age=age self.sex=sex ......
s1=OldboyStudent('李坦克','男',18) #先调用类产生空对象s1，
然后调用OldboyStudent.__init__(s1,'李坦克','男',18)
s2=OldboyStudent('王大炮','女',38)
s3=OldboyStudent('牛榴弹','男',78) #程序中对象的用法 #执行__init__,s1.name='牛榴弹'，
很明显也会产生对象的名称空间
s2.__dict__ {'name': '王大炮', 'age': '女', 'sex': 38}
 s2.name #s2.__dict__['name'] s2.name='王三炮' #s2.__dict__['name']='王三炮'
 s2.course='python' #s2.__dict__['course']='python' del s2.course #s2.__dict__.pop('course')