今日内容：
1.hash模块
2.xml模块
3.configparser模块
4.sheve 模块
5.shutil模块
知识点一：hash
什么是hash：
hash是一种算法，该算法接受传入的的内容，经过运算得到一串hash如果把hash算法比喻一座工厂
那传给hash算法的内容就是原材料，生产的hash值就是生产出的产品
为何用hash算法：
hash值产品有三大特性：
1.只要传入的内容一样，得到的hash值必然是一样的
2.只要我们使用的hash算法固定，无论传入的内容有多大得到的hash值得长度是固定的
3.不可以用hash值逆推原来的内容
基于1和2可以在下载文件时做文件一致性校验
基于1和3可以对密码进行加密
# 例如：
import hashlib
password=input(‘密码：‘)
m=hashlib.md5(‘天王盖地虎‘.encode(‘utf-8‘)) #可以多一层复杂性加密
m.update(password.encode(‘utf-8‘))
print(m.hexdigest())
‘‘‘
结果：
密码：123
41046ee2686f6c698c859a13b47cdb1f
‘‘‘
import hashlib
# 用法1：
#1.造工厂
m=hashlib.md5() #m=hashlib.sha256() 可以是其他加密个是
#2.运送材料
m.update(‘你好啊‘.encode(‘utf-8‘))
#3.产出hash值
print(m.hexdigest()) #124756ef340daf80196b4124686d651c
#用法2：
m=hashlib.md5(‘你‘.encode(‘utf-8‘)) #可以在造工厂的时候就添加材料
m.update(‘好啊‘.encode(‘utf-8‘))
print(m.hexdigest()) #124756ef340daf80196b4124686d651c hash结果：和上面一样，因为传入的材料是一样的
知识点二：xml
xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，
但json使用起来更简单
xml的格式如下，就是通过<>节点来区别数据结构的:
xml模块：
1.标签名 root.tag
2.便签属性 root.attrib
3.标签文本 root.text
以xml.xml文件为例：
<data>
<country name="Liechtenstein">
<rank updated="yes">2</rank>
<year>2008</year>
<gdppc>141100</gdppc>
<neighbor direction="E" name="Austria" />
<neighbor direction="W" name="Switzerland" />
</country>
<country name="Singapore">
<rank updated="yes">5</rank>
<year>2011</year>
<gdppc>59900</gdppc>
<neighbor direction="N" name="Malaysia" />
</country>
<country name="Panama">
<rank updated="yes">69</rank>
<year>2011</year>
<gdppc>13600</gdppc>
<neighbor direction="W" name="Costa Rica" />
<neighbor direction="E" name="Colombia" />
</country>
</data>
可以对xml文件进行一下操作：
import xml.etree.ElementTree as ET
tree=ET.parse(‘xml.xml‘) #parse单词：从语法上分析 理解
root = tree.getroot()
#对任何标签都有三个特征：便签名、标签属性、标签的文本内容
print(root.tag) #data
print(root.attrib) #标签属性 {}
print(root.text) #标签文本 空
print(list(root.iter(‘year‘)))
print(root.iter(‘year‘))
for year in root.iter(‘year‘):
print(year.tag)
print(year.attrib)
print(year.text)
print(‘========================‘)
# 在root的子节点找，只找一个
print(root.find(‘country‘).attrib) #{‘name‘: ‘Liechtenstein‘}
print(root.findall(‘country‘)) #[<Element ‘country‘ at 0x055F5CC0>,.. 列表格式
# 在root的子节点找，找所有
# 列表推导式，找出所有二级country本身的属性
print([country.attrib for country in root.findall(‘country‘)])
for country in root.findall(‘country‘):
print(country.attrib)
# 结果：
‘‘‘
{‘name‘: ‘Liechtenstein‘}
{‘name‘: ‘Singapore‘}
{‘name‘: ‘Panama‘}
‘‘‘
# 1.查
# 遍历整个文档
for country in root:
# print(‘========>国家%s‘%country.attrib)
for item in country:
print(item.tag) #year #rank
print(item.attrib) #<year>2008</year>属性标签为空：{} #{} #{‘updated‘: ‘yes‘}
print(item.text) #<year>2008</year>文本标签为2008 #2018 #2
# 2.改
for year in root.iter(‘year‘):
print(year.tag) #year year year
year.attrib={‘update‘:‘yes‘}
year.text=str(int(year.text)+1)
tree.write(‘xml.xml‘)
# 3.增加
for country in root:
rank=country.find(‘rank‘)
if int(rank.text)>50:
tag=ET.Element(‘egon‘) #element单词意思：元素 是否意思为增加一个名为egon的标签？？？
tag.attrib={‘update‘:‘yes‘}
tag.text=‘NB‘
country.append(tag)
tree.write(‘xml.xml‘)
# 4.删除
for country in root:
tag=country.find(‘egon‘)
# print(tag) #前两个country下面没有egon，所有没提示 None
if tag is not None:
print(‘====>‘)
country.remove(tag)
tree.write(‘xml.xml‘)
知识点三：configparser模块（解析配置文件）
主要所有三项：
1.config.sections 查看标题
2.config.options 查看指定标题下面所有key=value的key值
3.config.get 查看指定标题下面key=value的value值
4.config.items 查看取所有key、value的值以(key,value)格式显示
以文件config.ini格式为例：
[egon]
sex=‘female‘
age=20
salary=31
is_auth=True
[alex]
sex=‘male‘
age=20
salary=1
is_auth=True
可以进行一下操作：
import configparser
config=configparser.ConfigParser()
config.read(‘config.ini‘)
取标题
print(config.sections()) # ["‘egon‘", "‘alex‘"]
取文件标题下面下所有key=value的key
print(config.options(‘egon‘)) #[‘sex‘, ‘age‘, ‘salary‘, ‘is_auth‘]
取文件标题下面指定的key=value的value
print(config.get(‘egon‘,‘age‘)) #20
取所有key=value的(key,value)格式
print(config.items(‘egon‘))
[(‘sex‘, "‘female‘"), (‘age‘, ‘20‘), (‘salary‘, ‘31‘), (‘is_auth‘, ‘True‘)]
知识点四：sheve 模块（序列化和反序列化）
shelve更简单，也支持所有的的数据类型，但只能在python里面用
import shelve
f[‘stu1_info‘]={‘name‘:‘egon‘,‘age‘:18,‘hobby‘:[‘piao‘,‘smoking‘,‘drinking‘]}
f[‘stu2_info‘]={‘name‘:‘gangdan‘,‘age‘:53}
1.存文件
f=shelve.open(r‘shelve.txt‘)
2.取文件
print(f[‘stu1_info‘][‘hobby‘])
print(f[‘stu2_info‘][‘name‘])
3.改文件内容
注意点：
f[‘stu1_info‘][‘age‘]=44444 这样看是赋值改动，但是实际没有改，因为没有写入的文件
print(f[‘stu1_info‘])
要想写入,需要添加,writeback=True 将修改的文件写回后台文件
f=shelve.open(r‘shelve.txt‘,writeback=True)
f[‘stu1_info‘][‘age‘]=44444
print(f[‘stu1_info‘])
‘‘‘
输出结果为：
{‘name‘: ‘egon‘, ‘age‘: 44444, ‘hobby‘: [‘piao‘, ‘smoking‘, ‘drinking‘]}
知识点五：shutill模块
高级的 文件、文件夹、压缩包 处理模块
import shutil
拷贝文件
方式一：
with open(‘config.ini‘,‘r‘)as read_f,open(‘new.xml‘,‘w‘) as write_f:
shutil.copyfileobj(read_f,write_f)
方式二：shutil.copyfile(src, dst)
源文件事先定义好，目标文件无需存在，
shutil.copyfile(‘new.xml‘, r‘E:\f2.log‘) #拷贝到指定文件
shutil.copyfile(‘new.xml‘, ‘f2.log‘) #拷贝到当前文件夹
仅拷贝文件权限，内容、组、用户均不变 shutil.copymode(src, dst)
目标文件均不变，只是文件权限变动
shutil.copymode(‘new.xml‘, ‘f2.log‘)
仅拷贝状态信息，包括：mode bits, atime, mtime, flags
shutil.copystat(‘new.xml‘, r‘E:\f2.log‘)
拷贝文件和权限
import shutil
shutil.copy(‘f1.log‘, ‘f2.log‘)
递归的去拷贝文件夹
import shutil
shutil.copytree(‘folder1‘, ‘folder2‘, ignore=shutil.ignore_patterns(‘*.pyc‘, ‘tmp*‘)) #目标目录不能存在，
# 注意对folder2目录父级目录要有可写权限，ignore的意思是排除
递归的取删除文件
import shutil
shutil.rmtree(‘folder1‘)
#递归的去移动文件夹 shutil.move(src, dst)
import shutil
shutil.move(‘folder1‘, ‘folder3‘)
创建压缩包并返回文件路径
import shutil
‘‘‘
1.base_bak： 压缩后文件的名字，压缩包的文件名(也可以指定压缩好保存的具体文件目录）
如 data_bak=>保存至当前路径
如：/tmp/data_bak =>保存至/tmp/
2.gztar： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
3.root_dir： 被压缩文件的路径（默认当前目录）
4.owner： 用户，默认当前用户
5.group： 组，默认当前组
6.logger： 用于记录日志，通常是logging.Logger对象
‘‘‘
#res=shutil.make_archive(‘data_bak‘,‘gztar‘,root_dir=r‘E:\PycharmProjects\untitled\day17\包练习‘)
#解压文件(解压上面刚刚压缩的文件)
import tarfile
t=tarfile.open(r‘E:\PycharmProjects\untitled\day20\data_bak.tar.gz‘,‘r‘) #源文件路径
t.extractall(r‘E:\PycharmProjects\untitled\day20\dir_tarfile‘) #解压后文件存放路径
t.close()
知识点六：面向对象
面向对象编程：
对象：特征与技能的集合体，上帝的思维方式
优点：
可扩展性强
缺点:
编程的复杂程度要高于面向过程
类；类是一系列具有相同特征、技能对象的集合体
强调：站的角度不同，总结出来的来是截然不同的
现实世界中：先有对象，后才有类
在程序中：必须先定义类，后调用类来产生对象
《类里面尽量用驼峰体》
面向对象初始模板：
class OldboyStudent: #类的名称OldboyStudent
school=‘Oldboy‘ #特征（变量表示）
def learn(self): #就是一个普通函数
print(‘is learn skill‘) #技能1（函数表示）
def choice(self):
print(‘choose course‘) #技能2（函数表示）
print(OldboyStudent) #<class ‘__main__.OldboyStudent‘>
print(OldboyStudent.__dict__) #输出结果：如下
{‘__module__‘: ‘__main__‘, ‘school‘: ‘Oldboy‘, ‘learn‘:
<function OldboyStudent.learn at 0x05A9D810>, ‘choice‘: <function OldboyStudent.choice at 0x05A9D7C8>,
‘__dict__‘: <attribute ‘__dict__‘ of ‘OldboyStudent‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of
‘OldboyStudent‘ objects>, ‘__doc__‘: None}
Oldboy
print(OldboyStudent.__dict__[‘school‘]) #‘school‘是以字符串传值得
print(OldboyStudent.school)
OldboyStudent.learn(123) #OldboyStudent.learn(‘aaa‘)
注意理解：
OldboyStudent.learn(123) .后面跟的是类里面的属性，可以是变量名school和函数名learn
类的代码会在类定义阶段就立即执行，会产生一个类的名称空间
类的本身就是一个容器/名称空间，是用来存放名字的，这是类的用途之一
原文地址：https://www.cnblogs.com/yangzhizong/p/9225668.html