python模型在线更新

常用模块:

• 须知：import 模块名 导入模块

random模块：

'''
random.random()  # 获取[0.0,1.0)范围内的一个浮点数
random.randint(a, b)  # 获取这个[a,b]区间范围内的一个整数
random.uniform(a, b)  # 获取[a,b]区间范围内的浮点数
random.shuffle(x)  # 把 参数指定的数据中的元素 打乱，参数必须是一个可变的数据类型
random.sample(x,k)  # 从x中随机抽取k个数据，组成一个列表返回
''‘

• 练习

• 把参数指定的数据中的元素 打乱 参数必须时一个可变的数据类型

• 可变（不可哈希）的数据类型：list dict set -------修改后，原对象发生变化
  不可变（可哈希）的数据类型： str bool int tuple(元组) -----修改原对象，不会对原对象产生任何改变

lst = list(range(10))  # ---[0,1,2,3,4,5,6,7,8,9]

random.shuffle(lst)
print(lst)

+ 从x中随机抽取k个数据，组成一个列表返回

+ ```python
x = (1, 2, 3)
# 通过sample变相打乱
l = random.sample(x, len(x))
print(l)

time模块：

• 封装了获取时间戳和字符串形式的时间的一些方法

• 1.获取 时间戳

• 时间戳：从时间元年(1970.1.1 00:00:00)到现在经过的秒数

print(time.time()) # 1581688611.4762974

• 2.获取格式化时间对象：九个字段组成

• 默认参数是当前系统的时间戳

print(time.gmtime())  # GMT:
# time.struct_time(tm_year=2020, tm_mon=2, tm_mday=14, tm_hour=13, tm_min=56, tm_sec=51, tm_wday=4, tm_yday=45, tm_isdst=0)
print(time.localtime())  # 当地时间
# time.struct_time(tm_year=2020, tm_mon=2, tm_mday=14, tm_hour=21, tm_min=56, tm_sec=51, tm_wday=4, tm_yday=45, tm_isdst=0)

• 3.时间元年过一秒后对应的时间对象

print(time.gmtime(1))
# time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=1, tm_wday=3, tm_yday=1, tm_isdst=0)

• 4.格式化时间对象和字符串之间的转换

• 将时间对象转换成时间字符串

s = time.strftime("%Y %m %d %H:%M:%S")  # 年月日 时 分 秒
print(s)  # 2020 02 14 21:56:51

• 5.把时间字符串转换成时间对象

time_obj = time.strptime('2010 10 10', '%Y %m %d')
print(time_obj)
# time.struct_time(tm_year=2010, tm_mon=10, tm_mday=10, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=283, tm_isdst=-1)

• 时间对象 —> 时间戳

t1 = time.localtime()  # 时间对象
t2 = time.mktime(t1)  # 获取对应的时间戳
print(t2)  # 1581689092.0

时间对象，时间戳，时间字符串的表示方法
时间对象(结构化时间)：time.struct_time(tm_year=2020, tm_mon=1, tm_mday=9, tm_hour=11, tm_min=16, tm_sec=47, tm_wday=3, tm_yday=9, tm_isdst=0)
时间戳：1578568607.0
时间字符串(格式化时间)：2020 01 09 19:16:47

4.time.sleep(secs)
(线程)推迟指定的时间运行。单位为秒。

总结：

• 如有问题，查看上述time模块

# # 格式化时间 ---->  结构化时间
# ft = time.strftime('%Y/%m/%d %H:%M:%S')
# print(ft)  # 2020/02/14 21:49:14
# st = time.strptime(ft,'%Y/%m/%d %H:%M:%S')
# print(st)  # time.struct_time(tm_year=2020, tm_mon=2, tm_mday=14, tm_hour=21, tm_min=49, tm_sec=14, tm_wday=4, tm_yday=45, tm_isdst=-1)
# # 结构化时间 ---> 时间戳
# t = time.mktime(st)
# print(t)  # 1581688154.0
#
# # 时间戳 ----> 结构化时间
# t = time.time()
# st = time.localtime(t)
# print(st)  # time.struct_time(tm_year=2020, tm_mon=2, tm_mday=14, tm_hour=21, tm_min=49, tm_sec=14, tm_wday=4, tm_yday=45, tm_isdst=0)
# # 结构化时间 ---> 格式化时间
# ft = time.strftime('%Y/%m/%d %H:%M:%S',st)
# print(ft)  # 2020/02/15 21:56:08

序列化模块

json模块

• JavaScript Object Notation：Java脚本对象标记语言-----将大部分数据类型变成字符串，但集合（set）不可以
• 已经成为一种简单的数据交换格式
• 不完全的序列化----转化成 字符串的数据类型

1.json.dumps从内存到内存,在可转的情况下转化成字符串类型

• 列表序列化

s = json.dumps([1, 2, 3])
print(type(s))  # <class 'str'>  把指定的对象转换成json格式的字符串
print(s)  # 输出[1, 2, 3]     实际上'[1, 2,  3]'

• 元组可以json序列化，序列化后变成列表，但数据类型使字符串

s = json.dumps((1,2, 3))
print(s)  # [1, 2, 3]---------字符串类型   <class 'str'>

res = json.dumps(10)
print(res)  # 10 -----'10'    <class 'str'>

• 字典的序列化

res = json.dumps({'name':'Andy', 'age':10})
print(res)  # {"name": "Andy", "age": 10}  <class 'str'>

• set不能序列化

res = json.dumps(set('abc'))
print(res)  # TypeError: Object of type set is not JSON serializable

hashlib模块

• hashlib模块-学习：

• 封装一些用来加密的一些类:
• md5()----不可逆—王小云测算可逆
• 注意：加密的目的：用于判断和验证，而并非解密，
• 特点：

• 1.把一个大的数据，切分成不同快，分别对不同的快进行加密，再汇总的结果，和直接对整体数据加密的结果是一样的
• 2.单向加密，不可逆，
• 3.原始数据的一点小的变化，将导致结果的非常大的差异，'雪崩’效应

'''md5加密算法：
    给一个数据加密的三大步骤：
        1.获取一个加密对象（md5......）
        2.使用update方法进行加密，加密方法可以调用多次
        3.通常通过hexdigest获取加密结果，或digest()方法获取字节串
'''

# 1.获取一个加密对象
m = hashlib.md5()

# 2.使用加密对象的update，进行加密
m.update(b'abc')  # 字节类型的参数     b''里面不能加中文
m.update('abc中文'.encode('utf-8'))

# 3.（1）通过hexdigest获取加密的结果
res = m.hexdigest()
print(res)  # 1af98e0571f7a24468a85f91b908d335   ---字符串类型   ---16进制（四个二进制位）
# 3.（2）通过digest()方法加密结果获取字节串
res = m.digest()
print(res)  # b'\x1a\xf9\x8e\x05q\xf7\xa2Dh\xa8_\x91\xb9\x08\xd35'

• 给一个数据加密

• 验证：用另一个数据加密的结果和第一次加密的结果进行对比
• 如果加密结果一样，说明原文相同，如果不相同，说明原文不同

• 不同加密算法，加密结果的长度不同

s = hashlib.sha224()
s.update('abc'.encode('utf-8'))
print(s.hexdigest())  # 23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7

print(len(hashlib.md5().hexdigest()))  # 32个十六进制位
print(len(hashlib.sha256().hexdigest()))  # 64个十六进制位

• 在创建加密对象时，可以指定参数，成为salt 通过对原始口令加一个复杂字符串来实现，俗称“加盐“

m = hashlib.md5(b'abc')
print(m.hexdigest())  # 900150983cd24fb0d6963f7d28e17f72
#
m = hashlib.md5()
m.update('abc'.encode('utf-8'))
print(m.hexdigest())  # 900150983cd24fb0d6963f7d28e17f72

m = hashlib.md5(b'abc')
m.update('ccc'.encode('utf-8'))
print(m.hexdigest())  # bd1e6dd82ca1e4a0408d653407d13c85

• 把一个大的数据，切分成不同快，分别对不同的快进行加密，再汇总的结果，和直接对整体数据加密的结果是一样的

m = hashlib.md5()
m.update('abc'.encode('utf-8'))
m.update('def'.encode('utf-8'))
print(m.hexdigest())  # e80b5017098950fc58aad83c8c14978e

m = hashlib.md5()
m.update('abcdef'.encode('utf-8'))
print(m.hexdigest())  # e80b5017098950fc58aad83c8c14978e

• 注册登录程序

• 用户选择

def get_md5(username, passwd):
    # 获取加密对象
    m = hashlib.md5()
    # 使用加密对象的update，进行加密
    m.update(username.encode('utf-8'))
    m.update(passwd.encode('utf-8'))
    return m.hexdigest()

def register(username, passwd):
    # 获取返回值
    res = get_md5(username, passwd)
    # 写入文件  利用a模式操作文件，那么它会在文件的最后面追加内容
    with open('login', 'a') as f:
        f.write(res)
        f.write('\n')
def login(username, passwd):
    # 获取当前登录信息的加密结果
    res = get_md5(username, passwd)
    # 读文件，进行对比
    with open('login', 'r') as f:
        for line in f:
            if res == line.strip():
                return True
        else:
            return False
while True:
    op = int(input("1.注册 2. 登录 3.退出"))
    if op == 1:
        username = input("输入用户名：")
        passwd = input("输入密码：")
        register(username, passwd)

    elif op ==2:
        username = input("输入用户名：")
        passwd = input("输入密码：")
        res = login(username, passwd)
        if res:
            print('登录成功')
        else:
            print('登录失败')
    elif op == 3:
        break