打发点

 

单继承：

#__author : 'liuyang' 
#date : 2019/3/27 0027 上午 10:13
# class A(类的名字B):
#     pass

# A 就变成了 B 的儿子
    # B是 父类、基类、超类
    # A是 子类、派生类
class Parent:
    pass

class Son(Parent):
    pass
#单继承
print(Son.__bases__)#(<class '__main__.Parent'>,)


class Parent1:
    pass
# 多继承
class Son(Parent,Parent1):
    pass
print(Son.__bases__)#(<class '__main__.Parent'>, <class '__main__.Parent1'>)

# 为什么要继承
#两个类
    # 猫：
        # 属性：名字，品种
        # 动作：吃、喝、爬树、抓老鼠
    #狗：
        #属性：名字，品种
        #动作：吃、喝、抓老鼠、拆家
class Cat:
    def __init__(self,name,type):
        self.name = name
        self.type = type
    def eat(self,food):
        print('%s eat %s'%(self.name,food))
    def drink(self,water):
        print('%s drink %s'%(self.name,water))
    def catch(self):
        print('%s catch mouse'%(self.name))
    def climb(self):
        print('%s climb tree'%(self.name))
class Dog:
    def __init__(self,name,type):
        self.name = name
        self.type = type
    def eat(self,food):
        print('%s eat %s'%(self.name,food))
    def drink(self,water):
        print('%s drink %s'%(self.name,water))
    def catch(self):
        print('%s catch mouse'%(self.name))
    def chai(self):
        print('%s chai'%(self.name))
class Animal:
    def __init__(self,name,kind):
        self.name = name
        self.kind = kind
    def eat(self,food):
        print('%s eat %s'%(self.name,food))
    def drink(self,water):
        print('%s drink %s'%(self.name,water))
    def catch(self):
        print('%s catch mouse'%(self.name))

class Cat(Animal):
    def __init__(self,color):
        self.eyes_color = color
class Dog(Animal):pass
# cat1 = Cat('小花','橘猫')
# 子类指针找父类

# print(cat1)     #<__main__.Cat object at 0x000000000285F080>
# print(cat1.name)     #小花
# print(cat1.__dict__)     #{'name': '小花', 'kind': '橘猫'}
# cat1.eat('小鱼干')     #小花 eat 小鱼干

huang = Dog('小黑','中华犬')
print(huang.name)
huang.eat('单身狗粮')

class Cat(Animal):
    def __init__(self,name,kind,eyes_color):
        # Animal.__init__(self,name,kind) # 在子类和父类有同名方法的时候,默认只执行子类的方法
        #如果 想要 执行父类的方法，可以在子类的调用传参
        # super().__init__(name,kind)  # 不需要 传self  =====

        super(Cat,self).__init__(name,kind)  # 不需要 传self

        self.eyes_color = eyes_color # 派生属性

    def climb(self):  #派生方法
        print('%s climb tree'%self.name)
class Dog(Animal):pass

hua = Cat('小花','橘猫','blue')
print(hua.__dict__)
# 当Cat 自己拥有 __init__的时候,就不在调用父类了
hua.climb()

'''
子类的对象  想要使用一个名字
    #如果自己有 就用自己的
    #如果自己没有 就用父类的
    #如果父类也没有  就报错
#如果 就要使用的名字 父类子类都有
    # 即想使用子类的，也想使用父类的，那就在子类的方法中使用
        #1.父类名.方法名（self,参数1，参数2）
        #2.super().方法名（参数1，参数2）
'''
class A:pass      # 以后自动继承     object
class A(object):pass
print(A.__bases__)
# object 类

# 在 python 3当中 , 所有的类都继承 object 类，都是新式类
# 所有的类的类祖宗 都是object
# 父类是object 的类 ---新式类

class A(object):    #    def __init__(self): # known special case of object.__init__
                    #    """ Initialize self.  See help(type(self)) for accurate signature. """
    pass
a =A()       # 总是 要调用 init 的，如果我们不写,实际上就调用了父类object的————init__方法了
# a= A('abc')  # 但是不要参数   object() takes no parameters

例子

class Animal(object):
    def __init__(self,name,blood,ad):
        self.name = name
        self.hp = blood
        self.ad = ad

class Dog(Animal):
    def __init__(self,name,blood,ad,kind):
        Animal.__init__(self,name,blood,ad)
        self.kind = kind
    def bite(self,person):
        person.hp -= self.ad
        print('%s攻击了%s，%s掉了%s点血' % (self.name, person.name, person.name, self.ad))

class Person(Animal):
    def __init__(self,name,hp,ad,sex):
        super().__init__(name,hp,ad)
        self.sex = sex
    def fight(self,dog):
        dog.hp -= self.ad
        print('%s攻击了%s，%s掉了%s点血'%(self.name,dog.name,dog.name,self.ad))

hei = Dog('小黑',300,20,'哈士奇')
alex = Person('alex',20,1,'不详')
alex.fight(hei)
print(hei.hp)
hei.bite(alex)
print(alex.hp)

#  抽象
#  继承

# 组合 ： 什么有什么
# 继承 ： 什么是什么的关系
    #先想描述的对象
    #先写出 对象所对应的的类
    #发现多个类之间有相同的代码
    #把相同的代码提取出来，搞成一个父类

#先抽象 ，在继承 
#对象 ————》 类----》基类  
#基类 ----》 子类 ----》实例化----》对象

 

产品的哭泣声   自己就是工作，工作就是自己

 

多继承：

#__author : 'liuyang' 
#date : 2019/3/27 0027 上午 11:39
#各种动物，每一个动物都是一个类
#青蛙、天鹅、老虎
#青蛙：走，游泳
#天鹅：走，游泳，飞
#老虎：走，游泳
#鹦鹉：走，飞，说话
class FlyAnimal:
    def fly(self):
        pass
    def eat(self):pass
class SwimAnimal:
    def swim(self):
        pass
    def eat(self):pass  # 重复要哪个

class WalkAnimal:
    def walk(self):
        pass
class Frog(SwimAnimal,WalkAnimal):pass
class Tiger(SwimAnimal,WalkAnimal):pass
class Swan(FlyAnimal,SwimAnimal,WalkAnimal):pass
class Parrot(FlyAnimal,WalkAnimal):
    def talk(self):
        pass
# class Frog:
#     def walk(self):
#         pass
#     def swim(self):
#         pass
# class Tiger:
#     def walk(self):
#         pass
#     def swim(self):
#         pass
# class swan:
#     def walk(self):
#         pass
#     def swim(self):
#         pass
#     def fly(self):
#         pass
# class parrot:
#     def walk(self):
#         pass
#     def fly(self):
#         pass
# 多继承 是 python 语言中特有的继承方式
# java，c# 语言中 不支持 多继承
# c++  支持
# c  (c++ C# java) （面向对象）

# 多继承 和 单继承 是一样的
    # 如果 对象使用名字
    #是子类中有的，那么一定用子类的
    #子类没有的，可以到多个父类中去寻找
#如果多个和父类都有，那么用谁的

#钻石继承问题
class A:
    def func(self):
        print('a')

class B(A):
    def func(self):
        print('a')

#乌龟继承问题

    #广度优先
        #C3算法
    # 99% 的情况可以用眼睛看出来
    #但是仍然有1%的情况是看不出来的

# 别扭 因为效率 迭代重复 不好
#  大数据


A =[AO]
B = B, b节点的父类对应的顺序
B = B ,A 节点
B = B, [AO]
# c3 算法
    #提取第一个点
        #从左到右第一个类
        #第一个点，不在出现后续继承
        #提取出来，作为第一个类
B = [AO]
BA = [O]
顺序 ：[BAO]
C = C,[AO]
C = [AO]
CA = [O]
C 节点继承顺序 :[CAO]

l(D) = D+[BAO]
D = [BAO]
[DBAO]
l(E) = E+[CAO]
[ECAO]

l[F] = F,[DBAO],[ECAO]
[F] = [DBAO],[ECAO]
[FD] = [BAO],[ECAO]
[FDB] = [AO],[ECAO]
[FDBE] = [AO],[CAO]
[FDBEC] = [AO],[AO]
[FDBECA] = [O],[O]
[FDBECAO]

# 怎么回事 简单的 效率不高 复杂的效率高
print(H.mro())  #就是帮助我们来展示C3算法的继承顺序的

#super
#py2.7经典类
# 2 个图
# 自己去网上找一张图
    #看C3 mro  不一样的结果

#B的 super 是C

# 在单继承中，super 就是找父类
# 再多继承中，super 找的是mro顺序中的下一个类dbca
#  打印acbd
# 在多继承中，super 就只和mro顺序有关系 和父类子类没关系

b = B()
b.func()  # 只有ab 连c 也没有

# python 2.7
# 新式类  继承object
        #py2 要主动继承A(object) 才是新式类
        #广度优先 C3 算法
        #  有 mro()
        # 有super()  遵循 mro 
# 经典类  只在python. 默认不继承object A（object）
        #多个类之间去寻找方法的时候遵循深度优先
        # 博大精深  不科学所以  深度优先
        #没有 super 方法 也米有mro

# 多继承 2.7
#遵循的是 深度优先  (就是这么严谨的人)
# 不那么 好 平级可能有  去找下一级了

# python 的继承
#提高代码的重用性 ，减少了代码的冗余
#单继承
    #子类有的就找子类的，没有就找父类的
    #