Py-面向对象，组合，继承

面向对象

只有特定对象能使用特定的几个方法
对象=特征+动作

def dog(name,gender,type):
#狗的动作
    def jiao(dog):
        print('一条狗%s,汪汪汪' %dog['name'])
    def chishi(dog):
        print('一条狗%s,吃屎' %dog['name'])
    dog1={
     'name':name,
     'gender':gender,
     'type':type,
     'jiao':jiao,
     'chishi':chishi,
    }
    return dog1
d1=dog('a','公','中华田园犬')
d2=dog('b','母','犬')
print(d1)
d1['chishi'](d1)  #调用方式
d2['jiao'](d2)  #调用方式

类和对象

类：把一类事物相同的特征和动作整合到一起就是类，
类是一个抽象的概念
对象：是具体的存在，基于类而创建的具体的事物。
是特征和动作整合到一起的。
面向对象设计，使用class
class 类名字：
    '类的注释'
    类体
注意类名的开头标准写法是要大写
class Chinese:
    '这是一个中国人的类'
    pass
p1=Chinese()
print(p1)

具体实现方法

class Chinese:
    '这是一个中国人的类'
    dang='gcd'  #这样定义数据属性
    def smil():  #定义函数属性
        print('朝着墙上就是一口痰')
    def chadui(ap):
        print('跑到了前面')
print(Chinese.dang)  #数据属性调用方法
Chinese.smil()   #函数属性调用方法
Chinese.chadui('任意数')  #函数属性调用方法
print(Chinese.__dict__)  #查看类里面的所有属性
print(Chinese.__dict__['dang'])  #通过dict查看数据属性
print(Chinese.__dict__['smil']) #通过dict查看函数属性的地址
Chinese.__dict__['smil']()   #执行方式

下属方法

class Chinese:
    '这是一个中国人的类'
    dang='gcd'  #这样定义数据属性
    def smil():  #定义函数属性
        print('朝着墙上就是一口痰')
    def chadui(ap):
        print('跑到了前面')
print(Chinese.__name__)  #查看类标题名字
print(Chinese.__doc__)  #查看注释
print(Chinese.__base__)
print(Chinese.__bases__)
print(Chinese.__module__) #查看是否在当前文件进行的执行

具体的使用

class Chinese:
    '这是一个中国人的类'
    dang='gcd'  #这样定义数据属性
    def __init__(self,name,age,gender):   #init是系统内置
        self.mingzi=name  #创建self.mingzi变量并获取第一个数
        self.nianl=age  #创建self.mingzi变量并获取第2个数
        self.xingb=gender #创建self.mingzi变量并获取第3个数
        #不需要return，__init__会自动返回上面的创建的变量
    def smil(self):  #定义函数属性
        print('%s朝着墙上就是一口痰' %(self.mingzi))
    def chadui(self):
        print('跑到了前面')
p1=Chinese('杀马特','18','男')   #实例化
p1.smil()
print(p1.dang)
print(p1.__dict__)
print(Chinese.__dict__)

类属性的查看，删除，修改增加

class Chinese:
    '这是一个中国人的类'
    dang='gcd'  #这样定义数据属性
    def __init__(self,name,age,gender):   #init是系统内置
        self.mingzi=name  #创建self.mingzi变量并获取第一个数
        self.nianl=age  #创建self.mingzi变量并获取第2个数
        self.xingb=gender #创建self.mingzi变量并获取第3个数
        #不需要return，__init__会自动返回上面的创建的变量
    def smil(self):  #定义函数属性
        print('%s朝着墙上就是一口痰' %(self.mingzi))
    def chadui(self):
        print('跑到了前面')
p1=Chinese('杀马特','18','男')   #实例化
#查看类属性
print(Chinese.dang)
#修改类属性
Chinese.dang='gmd'
print(Chinese.dang)
#增加类属性
Chinese.qihou='hot'
print(Chinese.qihou)
#删除类属性
del Chinese.dang
print(Chinese.dang)

静态属性：装饰器property可以把函数属性变成数据属性来调用

class Chinese:
    '这是一个中国人的类'
    dang='gcd'  #这样定义数据属性
    def __init__(self,name,age,gender):   #init是系统内置
        self.mingzi=name  #创建self.mingzi变量并获取第一个数
        self.nianl=age  #创建self.mingzi变量并获取第2个数
        self.xingb=gender #创建self.mingzi变量并获取第3个数
        #不需要return，__init__会自动返回上面的创建的变量
    @property
    def smil(self):  #定义函数属性
        print('%s朝着墙上就是一口痰' %(self.mingzi))
    def chadui(self):
        print('跑到了前面')
p1=Chinese('杀马特','18','男')   #实例化
p1.smil

类方法：平常类里面的函数属性必须要用实例来运行，需要self，

使用classmethod装饰器可以将函数属性变成类可以直接调的。

class Chinese:
    '这是一个中国人的类'
    dang='abc'  #这样定义数据属性
    def __init__(self,name,age,gender):   #init是系统内置
        self.mingzi=name  #创建self.mingzi变量并获取第一个数
        self.nianl=age  #创建self.mingzi变量并获取第2个数
        self.xingb=gender #创建self.mingzi变量并获取第3个数
        #不需要return，__init__会自动返回上面的创建的变量
    @classmethod
    def smil(abc,dang):  #定义函数属性
        print('%s朝着墙上就是一口痰' %dang)
    def chadui(self):
        print('跑到了前面')
Chinese.smil(Chinese.dang)
Chinese.smil('dsada')

静态方法：@staticmethod 只是名义上属类，但是它实际上是与

类和实例剥离的

class Chinese:
    '这是一个中国人的类'
    dang='abc'  #这样定义数据属性
    def __init__(self,name,age,gender):   #init是系统内置
        self.mingzi=name  #创建self.mingzi变量并获取第一个数
        self.nianl=age  #创建self.mingzi变量并获取第2个数
        self.xingb=gender #创建self.mingzi变量并获取第3个数
        #不需要return，__init__会自动返回上面的创建的变量
    @staticmethod
    def smil(dang):  #定义函数属性
        print('%s朝着墙上就是一口痰' %dang)
    def chadui(self):
        print('跑到了前面')
Chinese.smil(Chinese.dang)

组合

class School:
    '这是一个课程的类'
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
class Course:
    '这是一个学校的类'
    def __init__(self,name,price,period,school):
        self.name=name
        self.price=price
        self.period=period
        self.school=school
s1=School('m870','地球')
s2=School('m870','月球')
c1=Course('吃屎学',10000,1,s1)  #组合后可以在c1内调用s1
print(c1.__dict__)
print(c1.school)
print(c1.school.name)
print(c1.school.addr)

弄成整体的选择课程系统

class School:
    '这是一个学校的类'
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
class Course:
    '这是一个kecheng的类'
    def __init__(self,name,price,period,school):
        self.name=name
        self.price=price
        self.period=period
        self.school=school
s1=School('m870','地球')
s2=School('m870','月球')
c1=Course('吃屎学',10000,1,s1)  #组合后可以在c1内调用s1
msg='''
1.m870 earth
2.m870 mooth
'''
while True:
    print(msg)
    menu={
        '1':s1,
        '2':s2,
}
    choice=input('选择学校>>')
    school_obj=menu[choice]
    print(school_obj.addr)

类的继承

继承代表子类的和父类的一样

1.单继承,多继承写法

class Parent1:
    pass
class Parent2:
    pass
class Subclass1(Parent1):  #单继承
    pass
class Subclass1(Parent1,Parent2): #多继承
    pass

2.单继承多继承实例

#单继承
class Dad:
    'd'
    money=10
    def __init__(self,name):
        print('dad')
        self.name=name
    def hit_son(self):
        print('%s 正在打儿子' %self.name)
class Son(Dad):
    pass
print(Son.money)  #能够使用父类的数据属性
s1=Son('bitch')#能够使用父类的函数属性
s1.hit_son()  #原理是如果子类里面没有的任何属性都会去父类找
#先找自己的数据属性和函数属性，有就优先，没有就找父类

3.当类之间有显著不同的时候可以写不同的类

有很多相关的功能的时候可以考虑继承
如果出了继承还需要派生新的可以找一个上一级的层次的类
class 动物
    动物共性
class 猫
    猫的特性
class 狗
    狗的特性

4.接口继承

import abc
class Allfile(metaclass=abc.ABCMeta):   #接口，大概说明子类需要实现的方法，不需要具体写
    @abc.abstractmethod    #限制后面的子类必须实现read方法，重写read
    def read(self):
         pass
    @abc.abstractmethod   #限制后面的子类必须实现write方法，重写write
    def write(self):
         pass
class Disk(Allfile):   #在子类里面需要具体写好接口中大致写的实现方法
     def read(self):
         print('read')
     def write(self):
         print('write')
class Cdrom(Allfile):
    pass
d1=Disk()
d1.read()
c1=Cdrom()
c1.read() #可以看见Cdrom没写接口内的限制函数属性就报错了

5.继承顺序：

python中的类可以继承多个类，python的类如果继承了多个类，那么寻找的方式
有两种，一种是深度优先，一种是广度优先
深度优先是a找里面的a[1]，然后继续找a[1]里面的a[1][1]，一直找到第一条路线里面的最底层
再找第一条路线里面的分支并且找到最底层再换分支。找完第一条路线再换其他路线。

广度优先是不会找到第一条最底层的那个，他只会找到最底层的上一级，然后直接回头找
其他分支到最底层的上一级，等到最后一个分支，它才找最底层。

示例：

class A:
    def test(self):
        print('a')
class B(A):
    def test(self):
        print('b')
class C(A):
    def test(self):
        print('c')
class D(B):
    def test(self):
        print('d')
class E(C):
    def test(self):
        print('e')
class F(D,E):
    pass
f1=F()
f1.test()
#继承属性顺序在mro
print(F.__mro__)
#左边从子类一直往右边的父类看，因为A没有父类，所以class object

在子类中调用父类的方法

class Vehicle:
    country='China'
    def __init__(self,name,speed,load,power):
        self.name=name
        self.speed=speed
        self.load=load
        self.power=power
    def run(self):
        print('开动了')
class Subway(Vehicle):
    def __init__(self,name,speed,load,power,line):
        Vehicle.__init__(self,name,speed,load,power)  #在子类中直接调用父类的init部分
        self.line=line
    def showinfo(self):
        print(self.name,self.speed,self.load,self.power,self.line)
line13=Subway('subway','10kms',100000,'电',13)
line13.showinfo()
super()的使用,子类中直接调用父类init
class Vehicle:
    country='China'
    def __init__(self,name,speed,load,power):
        self.name=name
        self.speed=speed
        self.load=load
        self.power=power
    def run(self):
        print('开动了')
class Subway(Vehicle):
    def __init__(self,name,speed,load,power,line):
        super().__init__(name,speed,load,power)  #在子类中直接调用父类的init部分
        self.line=line
    def showinfo(self):
        print(self.name,self.speed,self.load,self.power,self.line)
    def run(self):
        super().run()  #直接用super吧父类的init里的放进run里，可直接执行
        print('%s 跑路了' %self.name)
line13=Subway('subway','10kms',100000,'电',13)
line13.showinfo()
line13.run()

弄成用户输入型的，后面可以改界面，存文件等等

import pickle
class School:
    '这是一个学校的类'
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def save(self):
        with open('school.db','wb') as f:
            pickle.dump(self,f)
class Course:
    '这是一个kecheng的类'
    def __init__(self,name,price,period,school):
        self.name=name
        self.price=price
        self.period=period
        self.school=school
x=input('enter the school name>>')
y=input('enter the school addr>>')
s1=School(x,y)
s1.save()
school_obj = pickle.load(open('school.db','rb'))
print(school_obj.name,school_obj.addr)