python之路day7 面向对象继承&剩余模块

1 xml模块

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)
#
# tree.write('a.xml')

 

2 configparser模块

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))

# res1=config.getint('egon','age')#查看某个标题下的某个配置项的值
# print(type(res1))
#
# res1=config.getboolean('egon','is_admin')#查看某个标题下的某个配置项的值
# print(type(res1))
#
# res1=config.getfloat('egon','salary')#查看某个标题下的某个配置项的值
# 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'))

 

3 hashlib模块

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)



import hmac

h=hmac.new('hello'.encode('utf-8'))
h.update('world'.encode('utf-8'))
print(h.hexdigest())

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())

 

4 subprocess模块

import subprocess

# res=subprocess.Popen(r'deeddddir D:\04-视频录制存放目录\python18期\day7\xml模块',
#                      shell=True,
#                      stdout=subprocess.PIPE,
#                      stderr=subprocess.PIPE)
# # print('=================>',res)
# # print('-========>',res.stdout.read())
# print('-========>',res.stderr.read().decode('gbk'))
# print('-========>',res.stderr.read().decode('gbk'))
# print('-========>',res.stderr.read().decode('gbk'))
# print('-========>',res.stderr.read().decode('gbk'))


#dir file_path | findstr xml$
res1=subprocess.Popen(r'dir D:\04-视频录制存放目录\python18期\day7\xml模块',
                     shell=True,
                     stdout=subprocess.PIPE,)

# stdin=res1.stout
res2=subprocess.Popen(r'findstr xml$',
                     shell=True,
                     stdin=res1.stdout,
                     stdout=subprocess.PIPE,)


print(res2.stdout.read().decode('gbk'))

 

5 面向对象介绍与类 6 对象

'''
面向过程：核心是过程二字，过程指的是问题的解决步骤，即先干什么再干什么，基于
面向过程去设计程序就比如在设计一条流水线，是一种机械式的思惟方式
优势：复杂的问题流程化，进而简单化
缺点：可扩展性差
应用：脚本程序，好比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()

 

 

7 属性查找

 

8 继承

#继承的基本形式
# class ParentClass1(object): #定义父类
#     pass
#
# class ParentClass2: #定义父类
#     pass
#
# class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
#     pass
#
# class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
#     pass
#
#
#
#
# print(SubClass1.__bases__)
# print(SubClass2.__bases__)
# print(ParentClass1.__bases__)

#经典类与新式类的区别



# class Animal:
#     x=1
#     def __init__(self,name,age,sex):
#         self.name=name
#         self.age=age
#         self.sex=sex
#         # print('Animal.__init__')
#     def eat(self):
#         print('%s eat' %self.name)
#
#     def talk(self):
#         print('%s say' %self.name)
#
# class People(Animal):
#     x=10
#     def __init__(self,name,age,sex,education):
#         Animal.__init__(self,name,age,sex)
#         self.education=education
#         # print('People.__init__')
#
#     def talk(self):
#         Animal.talk(self)
#         print('这是人在说话')
#
# class Dog(Animal):
#     pass
# class Pig(Animal):
#     pass
#
#
# peo1=People('alex',18,'male','小学肄业')
# print(peo1.__dict__)
# peo1.talk()
# print(peo1.x)

# dog1=Dog('yuanhao',28,'male')
# pig1=Pig('wupeiqi',18,'male')
#
#
# print(peo1.name)
# print(dog1.name)
# print(pig1.name)




class OldboyPeople:
    school = 'oldboy'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def eat(self):
        print('is eating')

class OldboyStudent(OldboyPeople):
    def learn(self):
        print('%s is learning'  %self.name)


class OldboyTeacher(OldboyPeople):
    def __init__(self,name,age,sex,salary,title):
        OldboyPeople.__init__(self,name,age,sex)
        self.salary=salary
        self.title=title

    def teach(self):
        print('%s is teaching'  %self.name)


yl_obj=OldboyStudent('yanglei',28,'female')
egon_obj=OldboyTeacher('egon',18,'male',3.1,'沙河霸道金牌讲师')

#
# yl_obj.learn()
# yl_obj.eat()

print(egon_obj.__dict__)

'''
总结：
1 继承的功能之一：解决类与类之间的代码重复问题
2 继承是类与类之间的关系，是一种，什么是什么的关系
3 在子类派生出的新的属性，已本身的为准
4 在子类派生出的新的方法内重用父类的功能的方式：指名道姓法
OldboyPeople.__init__
  这种调用方式自己与继承是没有关系
'''

 

9 组合

class OldboyPeople:
    school = 'oldboy'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def eat(self):
        print('is eating')

class OldboyStudent(OldboyPeople):

    def __init__(self,name,age,sex):
        OldboyPeople.__init__(self,name,age,sex)
        self.course=[]

    def learn(self):
        print('%s is learning'  %self.name)


class OldboyTeacher(OldboyPeople):
    def __init__(self,name,age,sex,salary,title):
        OldboyPeople.__init__(self,name,age,sex)
        self.salary=salary
        self.title=title
        self.course=[]

    def teach(self):
        print('%s is teaching'  %self.name)


class Course:
    def __init__(self,course_name,course_period,course_price):
        self.course_name=course_name
        self.course_period=course_period
        self.course_price=course_price
    def tell_info(self):
        print('<课程名:%s 周期：%s 价格：%s>' %(self.course_name,self.course_period,self.course_price))

python=Course('Python','6mons',3000)
linux=Course('Lnux','3mons',2000)
bigdata=Course('BigData','1mons',1000)

# python.tell_info()


egon_obj=OldboyTeacher('egon',18,'male',3.1,'沙河霸道金牌讲师')
#
# egon_obj.course.append(python)
# egon_obj.course.append(linux)
#
# for obj in egon_obj.course:
#     obj.tell_info()


yl_obj=OldboyStudent('yanglei',28,'female')
yl_obj.course.append(python)

for i in yl_obj.course:
    # print(i.course_name,i.course_period,i.course_price)
    i.tell_info()

 

10 子类调用父类方法(super)

# class OldboyPeople:
#     school = 'oldboy'
#     def __init__(self,name,age,sex):
#         self.name=name
#         self.age=age
#         self.sex=sex
#
#     def eat(self):
#         print('is eating')
#     def teach(self):
#         print('这是父类的teach')
#
# class OldboyTeacher(OldboyPeople):
#     def __init__(self,name,age,sex,salary,title):
#         # OldboyPeople.__init__(self,name,age,sex)
#         #在Python2中须要写全：super(OldboyTeacher,self)
#         super().__init__(name,age,sex)
#         self.salary=salary
#         self.title=title
#
#     def teach(self):
#         # OldboyPeople.teach(self)
#         super().teach()
#         print('%s is teaching'  %self.name)
# print(OldboyTeacher.mro())
#
# egon_obj=OldboyTeacher('egon',18,'male',3.1,'沙河霸道金牌讲师')
# # print(egon_obj.title)
# # print(egon_obj.__dict__)
# egon_obj.teach()







class A:
    def test(self):
        super().test()

class B:
    def test(self):
        print('B')

class C(A,B):
    pass

# a=A()
# a.test()

print(C.mro())
c=C()
c.test()

 

11  绑定方法与非绑定方法

# import settings
#
# class MySql:
#     def __init__(self,host,port):
#         self.host=host
#         self.port=port
#
#     @classmethod
#     def from_conf(cls):
#         print(cls)
#         # return cls(settings.HOST,settings.PORT)
#
#     def func1(self):pass
#
#
# conn1=MySql('127.0.0.1',3306)

# print(MySql.from_conf)
# conn2=MySql.from_conf()

# print(conn1.host,conn2.host)

# print(conn1.func1)
# print(conn1.from_conf)
# print(MySql.from_conf)


# conn1.from_conf()
# MySql.from_conf()








import settings
import uuid
class MySql:
    def __init__(self,host,port):
        self.host=host
        self.port=port
        self.id=self.create_id()

    # @classmethod
    # def from_conf(cls): #绑定给类的
    #     print(cls)
    #     # return cls(settings.HOST,settings.PORT)
    #
    # def func1(self): #绑定给对象的
    #     pass

    @staticmethod
    def create_id(): #非绑定方法
        return str(uuid.uuid1())


conn1=MySql('127.0.0.1',3306)
conn2=MySql('127.0.0.2',3306)
conn3=MySql('127.0.0.3',3306)
# print(MySql.create_id)
# print(conn1.create_id)

print(conn1.id,conn2.id,conn3.id)