python_day07 常用模块xml/configparser/hashlib/subprocess 面向对象程序设计

常用模块
shutil
xml
configparser
hashlib
suprocess
面向对象的程序设计

 

常用模块

xml模块

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

import xml.etree.ElementTree as ET
tree=ET.parse('a.xml')
root=tree.getroot()
for child in root:
    print('====>',child.tag)
    for i in child:
        print(i.tag,i.attrib,i.text)
关注：标签名、属性、文本内容

#查找element元素的三种方式
years=root.iter('year') #扫描整个xml文档树，找到所有
for i in years:
    print(i)

res1=root.find('country') #谁来调，就从谁下一层开始找,只找一个
print(res1)
res2=root.findall('country') #谁来调，就从谁下一层开始找,只找一个
print(res2)

#修改子节点
years=root.iter('year') #扫描整个xml文档树，找到所有
for year in years:
    year.text=str(int(year.text)+1)
    year.set('updated','yes')
    year.set('version','1.0')
tree.write('a.xml')

#删除
for county in root.iter('country'):
    # print(county.tag)
    rank=county.find('rank')
    if int(rank.text) > 10:
        county.remove(rank)
tree.write('a.xml')

#增加节点
for county in root.iter('country'):
    e=ET.Element('egon')
    e.text='hello'
    e.attrib={'age':'18'}
    county.append(e)

#前面增删改操作一定要写入到a.xml才会生效
xmltree.write('a.xml')

configparser

[egon]
name = egon
is_admin = False
salary = 3.1

[alex]
name = alex
is_admin = True

import configparser
config=configparser.ConfigParser()
config.read('a.ini')
#取配置
print(config.sections()) #看标题
print(config.options(config.sections()[0])) #查看某个标题下的配置项
res=config.get('alex','name')#查看某个标题下的某个配置项的值
print(type(res))
# getint/getfloat/getboolean
res1=config.getfloat('egon','salary')#查看某个标题下的某个配置项的值
print(type(res1))
res1=config.getboolean('egon','is_admin')#查看某个标题下的某个配置项的值
print(type(res1))
#修改
config.remove_section('alex')
config.remove_option('egon','age')
#添加
config.add_section('alex')
config.set('alex','name','SB')
#写入文件
config.write(open('a.ini','w'))

hashlib

三个特点：
1.内容相同则hash运算结果相同，内容稍微改变则hash值则变
2.不可逆推
3.相同算法：无论校验多长的数据，得到的哈希值长度固定。

import hashlib
#如下几种加密方式结果一样
m=hashlib.md5()
m.update('hello'.encode('utf-8'))
m.update('world'.encode('utf-8'))
print(m.hexdigest())

m=hashlib.md5()
m.update('helloworld'.encode('utf-8'))
print(m.hexdigest())

m=hashlib.md5('helloworld'.encode('utf-8'))
print(m.hexdigest())

m=hashlib.md5('h'.encode('utf-8'))
m.update('elloworld'.encode('utf-8'))
print(m.hexdigest())

#加密文件
m=hashlib.md5()
with open('a.xml','rb') as f:
    for line in f:
        m.update(line)
print(m.hexdigest())
#耗费内存不推荐使用
m=hashlib.md5()
with open('a.xml','rb') as f:
    m.update(f.read())
print(m.hexdigest())

#加盐
password='alex3714'
m=hashlib.md5('yihangbailushangqingtian'.encode('utf-8'))
m.update(password.encode('utf-8'))
passwd_md5=m.hexdigest()
print(passwd_md5)

#hmac模块
#默认第一次加密就会加盐
import hmac
h=hmac.new('hello'.encode('utf-8'))
h.update('world'.encode('utf-8'))
print(h.hexdigest())
#0e2564b7e100f034341ea477c23f283b
h=hmac.new('hel'.encode('utf-8'))
h.update('loworld'.encode('utf-8'))
print(h.hexdigest())
#2b8861887b9670e3b042475182619b5d
h=hmac.new('hello'.encode('utf-8'))
h.update('w'.encode('utf-8'))
h.update('or'.encode('utf-8'))
h.update('ld'.encode('utf-8'))
print(h.hexdigest())
#0e2564b7e100f034341ea477c23f283b

suprocess

import subprocess
res=subprocess.Popen(r'deeddddir D:\04-视频录制存放目录\python18期\day7\xml模块',
                     shell=True,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE)
print('=================>') #程序会先打印此处
print('=================>',res)
print('-========>',res.stdout.read())
print('-========>',res.stderr.read().decode('gbk'))     #windows为gbk解码，Linux为ut-8解码
print('-========>',res.stderr.read().decode('gbk'))     #管道信息只获取一次，之后再获取就没有了

#dir file_path | findstr xml$
res1=subprocess.Popen(r'dir E:\获取的资料\老男孩教育-Python自动化课程-20170701\day07\day7纯代码\xml模块',
                     shell=True,
                     stdout=subprocess.PIPE,)
stdin=res1.stdout    #输出作为下一次的输入
res2=subprocess.Popen(r'findstr xml$',
                     shell=True,
                     stdin=res1.stdout,
                     stdout=subprocess.PIPE,)
print(res2.stdout.read().decode('gbk'))

面向对象的程序设计

面向过程：核心是过程二字，过程指的是问题的解决步骤，即先干什么再干什么，基于
面向过程去设计程序就好比在设计一条流水线，是一种机械式的思维方式
优点：复杂的问题流程化，进而简单化
缺点：可扩展性差
应用：脚本程序，比如linux系统管理脚本，著名案例：linux内核，httpd，git

面向对象：核心是对象二字，对象就是特征与技能的结合体，如果把设计程序比喻成
创造一个世界，那你就是这个世界的上帝，与面向过程对机械流水的模拟形式鲜明的对比
面向对象更加注重的对现实时间的模拟。
优点：可扩展性
缺点：复杂性高

类即种类，类别，对象是特征和与技能的结合体，那么类就是一系列对象相似的
特征与技能的结合体
在现实世界中：先有一个个具体存在的对象----》（总结相似之处）---》现实中的类
在程序中：一定是先定义类，后调用类来产生对象
类与对象

#第一阶段：现实中的对象----》现实中类
obj1：
    特征
        学校=oldboy
        名字=李大炮
        年龄=18
        性别=女
    技能
        学习
        吃饭
obj2：
    特征
        学校=oldboy
        名字=张全蛋
        年龄=28
        性别=男
    技能
        学习
        吃饭

obj3：
    特征
        学校=oldboy
        名字=牛榴弹
        年龄=18
        性别=女
    技能
        学习
        吃饭
现实中的老男孩学生类：
    相似的特征
        学校=oldboy
    相似的技能
        学习
        吃饭
#第二阶段：程序中的类----》程序中的对象
class OldboyStudent:
    school = 'oldboy' #类的数据属性
    def learn(self): #类的函数属性
        print('is learning')

    def eat(self):
        print('is eating')
    print('======>')
#类体的代码在类定义阶段就会执行,理所应当会产生类的名称空间，用__dict__属性查看
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['learn'])
#类的属性操作
print(OldboyStudent.school)
print(OldboyStudent.learn)
def func():pass
print(func)
OldboyStudent.learn(123)

OldboyStudent.x=1111111111111111111111
OldboyStudent.school='Oldboy'
del  OldboyStudent.school
print(OldboyStudent.__dict__)

OldboyStudent.__dict__['x']=1111111111111111111111
class OldboyStudent:
    school = 'oldboy'
    #obj1,'李大炮',18,'女'
    def __init__(self,name,age,sex): #在实例化时,产生对象之后执行
        # if not isinstance(name,str):
        #     raise TypeError('名字必须是字符串类型')
        self.name=name
        self.age=age
        self.sex=sex
        # return None #__init__方法必须返回None
        #obj1.name='李大炮'
        #obj1.age=18
        #obj1.sex='女'
    def learn(self):
        print('is learning')
    def eat(self):
        print('is eating')
obj1=OldboyStudent('李大炮',18,'女') #
#分两步：
#第一步：先产生一个空对象obj1
#第二步：OldboyStudent.__init__(obj1,'李大炮',18,'女')
print(obj1.__dict__)
obj2=OldboyStudent('张全蛋',28,'男')
obj3=OldboyStudent('牛榴弹',18,'女')
print(obj2.__dict__)
print(obj3.__dict__)
print(obj1.name)#obj1.__dict__['name']
obj1.name='大炮'
print(obj1.__dict__)
obj1.__dict__['name']='炮'
print(obj1.name)
obj1.__dict__.pop('name')
# print(obj1.name)
print(obj1.__dict__)
obj1=OldboyStudent(123123123,18,'女') #

school='hahahahahahaah'
class OldboyStudent:
    # school = 'oldboy'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def learn(self):
        print('%s is learning'  %self.name)
    def eat(self):
        print('is eating')
obj1=OldboyStudent('李大炮',18,'女')
obj2=OldboyStudent('张全蛋',28,'男')
obj3=OldboyStudent('牛榴弹',18,'女')
print(obj1.__dict__)
print(obj1.name,obj1.age,obj1.sex)
#对象可以访问类的数据属性，结论：类的数据属性共享给所有对象使用，id对一样
print(obj1.school,id(obj1.school))
print(obj2.school,id(obj2.school))
print(obj3.school,id(obj3.school))
print(OldboyStudent.school,id(OldboyStudent.school))
#类的函数属性是绑定给所有对象使用的，绑定给不同的对象是不同的绑定方法，绑定方法有何特殊之处？
#暂且抛开绑定方法，类肯定可以访问自己的函数属性
OldboyStudent.learn(obj1)
OldboyStudent.learn(obj2)
OldboyStudent.learn(obj3)
print(obj1.learn)
print(obj2.learn)
print(obj3.learn)
print(OldboyStudent.learn)
#绑定方法：绑定给谁，就由谁来调用，谁来调用就把“谁”本身当做第一个参数传入
obj1.learn() #OldboyStudent.learn(obj1)
obj2.learn() #OldboyStudent.learn(obj1)
obj3.learn() #OldboyStudent.learn(obj1)
#在python3中类型就类
print(OldboyStudent)
print(list)

l1=list()
l2=list()
l3=list()
print(type(l1))
print(type(obj1))
l1.append(3) #list.append(l1,3)
list.append(l1,3)
print(l1)
print(l2)
print(l3)
#属性查找顺序：先从对象的__dict__中找，然后到类的__dict__中找，然后父类....
OldboyStudent.school='哈佛'
obj1.school='hahahahahahahhahahahahahah'
print(obj1.__dict__)
print(obj1.school)
print(obj2.school)
print(obj3.school)

class Foo:
    count=0
    def __init__(self,x,y,z):
        self.x=x
        self.y=y
        self.z=z
        Foo.count+=1
obj1=Foo(1,1,1)
obj2=Foo(1,2,1)
obj3=Foo(1,2,3)
print(obj1.count)
print(Foo.count)

class OldboyStudent:
    # school = 'oldboy'
    def __init__(self,name,age,sex='male'):
        self.name=name
        self.age=age
        self.sex=sex
    def learn(self):
        print('%s is learning'  %self.name)
    def eat(self,y):
        print('is eating')
obj1=OldboyStudent('李大炮',18)
OldboyStudent.eat()
obj1.eat(1)
obj1.learn()

对象直接的交互

class Garen:
    camp='Demacia'
    def __init__(self,nickname,life_value=100,aggresivity=80):
        self.nickname=nickname
        self.life_value=life_value
        self.aggresivity=aggresivity
    def attack(self,enemy):
        enemy.life_value-=self.aggresivity
class Riven:
    camp = 'Noxus'
    def __init__(self, nickname, life_value=80, aggresivity=100):
        self.nickname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity
    def attack(self, enemy):
        enemy.life_value -= self.aggresivity
g1=Garen('草丛猥琐男')
r1=Riven('兔女郎')
print(r1.life_value)
g1.attack(r1)
print(r1.life_value)