莫名其妙，hashlib模块等剩余模块、面向对象编程、类，第三十四天

最新推荐文章于 2024-04-26 21:02:24 发布

十八岁的有德

最新推荐文章于 2024-04-26 21:02:24 发布

阅读量127

点赞数

文章标签： python

本文链接：https://blog.csdn.net/weixin_42157426/article/details/80801491

版权

人蠢就蠢在自己活了几十年一事无成，不以为自己错了，还非得把自己的这种观念、思想教授给别人，他人不需要时还硬要帮倒忙，并且沾沾自喜，非要让他人呵斥一声才罢休！活了几十年还不明白自己是头蠢驴，不是蠢驴几十载光阴岂会活成这样。

我一定要努力，努力脱离我现在所处的圈子，往高处走！！！！！！！！！！！！！！一定

说点鸡汤点的：

人生百态才是常态，有人注定成凤成龙，有人注定平凡一生，不勉强自己，不随风而逝，顺势而为才是正途。该奋斗的奋斗，该堕落的堕落，不强求，不为难，顺其自然！

1、hashlib模块

1、什么时hash：

hash是一种算法，该算法接受传入的内容，经过运算得到一串hash值

如果把hash算法比喻为一座工厂

那传给hash算法的内容就是原材料

生成的hash值就是生产出的产品

2、为何要用hash算法：

hash值/产品有三大特性：

1、只要传入的内容一样，得到的hash值必然一样

2、只要我们使用的hash算法固定，无论传入的内容有多大，得到的hash值的长度是固定的

3、不可以用hash值逆推出原来的内容

基于1和2可以在下载文件时做文件一致性校验

基于1和3可以对密码进行加密

3、如何用

1.打造出hash工厂

2.运送原材料

3.产出hash值

具体代码：

import hashlib

1、造出hash工厂
m=hashlib.md5()

2、运送原材料
m.update('你好啊美丽的'.encode('utf-8'))
m.update('张铭言'.encode('utf-8'))

3、产出hash值
print(m.hexdigest()) #66bcb9758826f562ae8cb70d277a4be9


1、造出hash工厂
m=hashlib.md5('你'.encode('utf-8'))

2、运送原材料
m.update('好啊美丽的张铭言'.encode('utf-8'))

3、产出hash值
print(m.hexdigest()) #66bcb9758826f562ae8cb70d277a4be9



应用一：文件一致性校验
1、造出hash工厂
m=hashlib.sha512('你'.encode('utf-8'))

2、运送原材料
m.update('好啊美sadfsadf丽asdfsafdasdasdfsafsdafasdfasdfsadfsadfsadfsadfasdff的张铭言'.encode('utf-8'))


3、产出hash值
print(m.hexdigest()) #2ff39b418bfc084c8f9a237d11b9da6d5c6c0fb6bebcde2ba43a433dc823966c


1、造出hash工厂
m=hashlib.md5()

2、运送原材料
with open(r'E:\01.mp4','rb') as f: # 打开文件获取原材料
    for line in f: # 避免文件过大，分行hash，实际上是没传输百分之多少左右hash一次
        m.update(line) 
3、产出hash值
print(m.hexdigest()) #1273d366d2fe2dc57645cc1031414a05
                    1273d366d2fe2dc57645cc1031414a05


应用一：对明文密码进行加密
password=input('>>>: ')

m=hashlib.md5()
m.update('天王盖地虎'.encode('utf-8')) # 加盐，也就是给密码加一段字符串为hash值比对增添干扰
m.update(password.encode('utf-8'))
print(m.hexdigest()) #95bd6eafefdf51d8b153785f3fb6263d



import hmac # 另一种hash的方法

m=hmac.new('小鸡炖蘑菇'.encode('utf-8')) # 加盐，这种模式下必须加盐
m.update('hello'.encode('utf-8'))
print(m.hexdigest())

2、shutil模块

快速拷贝文件:

import shutil

with open('old.xml', 'r') as read_f, open('new.xml', 'w') as write_f:　＃　打开需要被复制的文件以及复制文件的地址
    shutil.copyfileobj(read_f, write_f)＃　复制文件

压缩文件：

import shutil
shutil.make_archive("data_bak", 'gztar', root_dir='D:\SH_fullstack_s2\day04')　＃　压缩文件

解压文件：tarfile

import tarfile

t = tarfile.open('data_bak.tar.gz', 'r') #　打开需要解压的文件
t.extractall('D:\SH_fullstack_s2\day20\dir') # 　解压后文件存放的地址
t.close()　＃　关闭文件

3、shelve模块

序列与反序列的另一种形式，用的比较少，支持python的所有数据类型

import shelve

dic1={'pwd':'alex3714','age':18,'sex':'male'} # 新建一个字典dic1
dic2={'pwd':'alex3715','age':73,'sex':'male'} # 新建另一个字典dic2

d=shelve.open('db.txt',writeback=True) # 用shelve模式打开文件，writeback默认False，True表示可以写入
d['egon']=dic1 # 给dic1设置一个键名'egon'
d['alex']=dic2 # 给dic2设置一个键名'alex'
d['egon']['age']=19 # 修改'egon'中'age'对应的值为19
print(d['egon'])#　打印'egon'所对应的值dic1
d.close() # 关闭文件

4、xml模块

存取文件的一种格式，远古版，现已被json代替

import xml.etree.ElementTree as ET # 导出模块并命名为ET

tree = ET.parse("a.xml") # 打开'a.xml'文件
root = tree.getroot() # 获取'a.xml'文件下的所有分支

对于任何标签都有三个特征：标签名、标签属性、标签的文本内容
print(root.tag) # 获取标签名
print(root.attrib) # 获取标签属性
print(root.text) # 获取标签的文本内容

print(list(root.iter('year'))) #全文搜索,找到所有
for year in root.iter('year'): # 因为root.iter('year')是一个迭代器，所以用for循环取出
    print(year.tag) # 获取'year'的标签名
    print(year.attrib) # 获取'year'的属性
    print(year.text) # 获取'year'的文本内容


print(root.find('country').attrib) #在root的子节点找，只找一个
print([country.attrib for country in root.findall('country')]) #在root的子节点找，找所有


1、查
遍历整个文档
for country in root: # 遍历root可以获取一级标签country
    print('============>国家 %s' %country.attrib)
    for item in country: # 再次遍历可以获得一级标签country下的 所有子标签
        print(item.tag)
        print(item.attrib)
        print(item.text)

2、改
for year in root.iter('year'): # 首先获取'year'标签
    print(year.tag)
    year.attrib={'updated':'yes'} # 给'year'增添一个新属性'updated'
    year.text=str(int(year.text)+1) # 把'year'标签的文本内容+1，切记取出和存进的都是str数据类型

tree.write('a.xml') # 写入'a.xml'文件，其实是重新覆盖文件，而不是在文件本身上修改

3、增
for country in root:  
    rank=country.find('rank')
    if int(rank.text) > 50: # 判断'rank'文本内容>50的rank的标签
        # print('符号条的国家',country.attrib)
        tag=ET.Element('egon') # 在'rank'>50的rank的标签中添加一个新标签'egon'
        tag.attrib={'updated':'yes'} # 'egon'的属性新增一个'updated'
        tag.text='NB' # 'egon'的文本内容修改为'NB'
        country.append(tag) # 添加新标签

tree.write('a.xml') # 写入'a.xml'文件
4、删

for country in root:
    tag=country.find('egon') # 注意：tag无论是否为空，bool值都是False，查找'egon'标签
    # print(tag,bool(tag))
    if tag is not None: # 判断'tag'标签是不是空的
        print('====>')
        country.remove(tag) ＃删除该'tag'标签
tree.write('a.xml')

5、configparser模块

对配置文件进行操作

import configparser

config=configparser.ConfigParser() # 打开ConfigParser功能，并命名为config
config.read('config.ini') #a.cfg a.ini a.cnf # 可以读取的文件类型

print(config.sections()) # 获取配置文件的主要模块
print(config.options('egon')) # 获取配置文件的键
print(config.items('egon')) # 获取配置文件的键值


res=config.get('egon','age') # 获取配置文件的'age'，得到的是字符串类型
res=config.getint('egon','age') # 获取配置文件的'age'，得到的是整型数据类型

print(res,type(res))

res=config.getfloat('egon','salary') # 获取配置文件的浮点型数据类型
print(res,type(res))

res=config.getboolean('egon','is_beautiful') # 获取配置文件的bool型数据类型
print(res,type(res))

6、面向对象编程

面向过程变成

核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么然后干什么

基于该思想编写程序好比在设计一条流水线，是一种机械式的思维方式

优点：

复杂的问题流程化、进而简单化

缺点：

扩展性差

面向对象编程

核心对象二字，对象是特征与技能的结合体

基于该思想编写程序就好比是在创造一个世界，你就是这个世界的上帝，是一种上帝式的思维

优点:

可扩展性强

缺点：编程的复杂度高于面向过程编程

7、类

类：种类、分类、类别、

对象是特征与技能的结合体，类是一系列对象相似的特征与技能的结合体

强调：站的角度不同，总结出的类是截然不同的

在现实世界中：先有的一个个具体存在的对象，然后随着人类文明的发展才有了分类的概念

在程序中：必须先定义类，后调用类来产生对象

站在老男孩选课系统的角度，先总结现实世界中的老男孩的学生对象

对象1：
    特征：
        学校='oldboy'
        姓名='耗哥'
        年龄=18
        性别='male'
    技能：
        选课

对象2：
    特征：
        学校='oldboy'
        姓名='猪哥'
        年龄=17
        性别='male'
    技能：
        选课

对象3：
    特征：
        学校='oldboy'
        姓名='帅翔'
        年龄=19
        性别='female'
    技能：
        选课

站在老男孩选课系统的角度，先总结现实世界中的老男孩学生类

老男孩学生类：
    相似的特征：
        学校='oldboy'
    相似的技能
        选课

在程序中

1、先定义类

class OldboyStudent:
    school='oldboy'

    def choose_course(self):
        print('is choosing course')

类体代码会在类定义阶段就立刻执行，会产生一个类的名称空间

类的本身其实就是一个容器/名称空间，是用来存放名字的，这是类的用途之一

print(OldboyStudent.__dict__) # 获取OldboyStudent中的所有名称

print(OldboyStudent.__dict__['school']) # 获取school对应的值
print(OldboyStudent.__dict__['choose_course']) # 获取choose_course对应的函数
OldboyStudent.__dict__['choose_course']()

print(OldboyStudent.school) #OldboyStudent.__dict__['school']
print(OldboyStudent.choose_course) #OldboyStudent.__dict__['choose_course']

OldboyStudent.choose_course(111)

OldboyStudent.country='China' #OldboyStudent.__dict__['country']='China'
OldboyStudent.country='CHINA' #OldboyStudent.__dict__['country']='China'
del OldboyStudent.school
print(OldboyStudent.__dict__)

2、后调用类产生对象，调用类的过程，又称为类的实例化，实例化的结果称为类的对象/实例

stu1=OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例
stu2=OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例
stu3=OldboyStudent() # 调用类会得到一个返回值，该返回值就是类的一个具体存在的对象/实例

思考题：

类的实例化过程都发生了哪些事？
如何在实例化的过程中为对象定制自己独有的特征
程序中对象到底是什么，如何使用？

十八岁的有德

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫