面向对象的三大特性: 继承

class Animal:
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age

class Person:
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age

class Cat:
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age

class Dog:
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age

p1 = Person('alex','laddyboy',1000)

class Animal:
    breath = '呼吸'

    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age

    def eat(self):
        print(self)
        print('动物都需要进食....')


class Person(Animal):  # 括号里面的 父类,基类,超类   括号外面的 子类,派生类.
    pass

class Cat:
    pass

class Dog:
    pass

p1 = Person('alex', 'laddyboy', 1000)
print(p1.__dict__)

# 初识继承:

　　# 子类以及子类实例化的对象 可以访问父类的任何方法或变量.

# 类名可以访问父类所有内容

　　# print(Person.breath)
　　# Person.eat(111)

# 子类实例化的对象也可以访问父类所有内容

　　# print(p1.breath)
　　# print(p1)
　　# p1.eat()

#  写三个类: 狗,猫,鸡, 每个类中都有 吃 喝  自己的方法  最后定义一个Animal类,

class Animal:

    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age

    def eat(self,a1):
        print('%s吃%s' % (self.name,a1))

    def drink(self):
        print('%s喝东西' % (self.name))


class Cat(Animal):

    def miaow(self):
        print('喵喵叫')
    # def eat(self):  # 只执行自己类中的方法
    #     print(666)

class Brid(Animal):

    def __init__(self, name,sex,age,wing): # self b1对象 name '鹦鹉',sex '公',age 20,  wing '绿翅膀'
        '''
        self=b1对象
        name='鹦鹉'
        sex='公'
        age= 20,
        wing='绿翅膀'
        '''
        # Animal.__init__(self, name, sex, age)
        super().__init__(name,sex,age)  #  super(Brid,self).__init__(name,sex,age)
        self.wing = wing
    def bark (self):
        print('嗷嗷叫')

    def eat(self,argv):
        super().eat(argv)
        print('鸟吃虫子...')

class Chook(Animal):
    def crow(self):
        print('大爷laiwanya')
# cat1 = Cat('tom','公', 3)
# # cat1.eat()

# 只执行父类的方法:子类中不要定义与父类同名的方法
# 只执行子类的方法:在子类创建这个方法.
# 既要执行子类的方法,又要执行父类的方法?
# 有两种解决方法.
    # 1,Animal.__init__(self, name, sex, age)
    # 1,super().__init__(name,sex,age)
# cat1 = Cat('tom','公', 3,)
#
# b1 = Brid('鹦鹉','公',20,'绿翅膀')
#   print(b1.__dict__)
# b1.eat('金蝉')

# 继承的进阶
# 继承: 单继承,多继承.

# 类: 经典类, 新式类
# 新式类: 凡是继承object类都是新式类.
    # python3x 所有的类都是新式类,因为python3x中的类都默认继承object.
# class A:
#     pass
# 经典类: 不继承object类都是经典类
    #python2x:(既有新式类,又有经典类) 所有的类默认都不继承object类,所有的类默认都是经典类.你可以让其继承object.

# 单继承: 新式类,经典类查询顺序一样.

class A:
    pass
    # def func(self):
    #     print('IN A')

class B(A):
    pass
    # def func(self):
    #     print('IN B')

class C(B):
    pass
    # def func(self):
    #     print('IN C')

c1 = C()
c1.func()

# 多继承:
    #  新式类: 遵循广度优先.
    #  经典类: 遵循深度优先.

# 多继承的新式类  
广度优先 : 一条路走到倒数第二级,判断,如果其他路能走到终点,则返回走另一条路.如果不能,则走到终点.

class A:
    def func(self):
        print('IN A')

class B(A):
    pass
    # def func(self):
    #     print('IN B')

class C(A):
    pass
    # def func(self):
    #     print('IN C')

class D(B):
    pass
    # def func(self):
    #     print('IN D')

class E(C):
    pass
    # def func(self):
    #     print('IN E')

class F(D,E):
    pass
    # def func(self):
    #     print('IN F')

f1 = F()
f1.func()


class A:
    def func(self):
        print('IN A')

class B(A):
    pass
    # def func(self):
    #     print('IN B')

class C(A):
    pass
    # def func(self):
    #     print('IN C')

class D(B):
    pass
    # def func(self):
    #     print('IN D')

class E(C):
    def func(self):
        print('IN E')

class F(D,E):
    pass
    # def func(self):
    #     print('IN F')

f1 = F()
f1.func()

print(F.mro())  # 查询类的继承顺序

# 多继承的经典类  深度优先 : 一条路走到底.

class A:
    pass
    # def func(self):
    #     print('IN A')

class B(A):
    pass
    # def func(self):
    #     print('IN B')

class C(A):
    # pass
    def func(self):
        print('IN C')

class D(B):
    pass
    # def func(self):
    #     print('IN D')

class E(C):
    # pass
    def func(self):
        print('IN E')

class F(D,E):
    pass
    # def func(self):
    #     print('IN F')

f1 = F()
f1.func()

简单总结:
    继承的优点:

　　1. 优化代码,节省代码.
　　2. 提高代码的复用性.
　　3. 提高代码的维护性.
　　4. 让类与类之间发生关系.
　　组合: 让对象与对象发生关系.

    初识继承:
        只执行本类的方法
        只执行父类的方法.
        既执行本类又执行父类的方法
            父类名.方法名(参数)
            super().方法名(参数(self自动传值))

    单继承,多继承.
    类:新式类,经典类.

    单继承;
        新式类经典类一样.
    多继承:
        新式类:广度优先  类名.mro()  新式类.
        经典类:深度优先.

习题
1.

# a,定义一个父类Animal，在构造方法中封装三个属性，姓名，性别，年龄，
# 再给其添加一个eat的方法，方法中显示%s正在吃饭（%s是哪个对象调用此方法，显示哪个对象名字）。
# b,定义两个子类Person,Dog，全部继承这个父类Animal.
# c,Person类中，有构造方法，封装一个皮肤的属性，有eat方法，方法中显示人类正在吃饭。
# d,Dog类中，有构造方法，封装一个毛色的属性，有eat方法，方法中显示狗狗正在吃饭。
# 上面这几个类创建完成之后，完成下列要求：
# ①：    实例化一个人类的对象，让其只封装皮肤属性。
# ②： 实例化一个人类的对象，让其封装姓名，性别，年龄，皮肤四个属性。
# ③： 实例化一个狗类的对象，让其只封装毛色属性。
# ④： 实例化一个狗类的对象，让其封装姓名，性别，年龄，毛色四个属性。
# ⑤： 实例化一个人类的对象，让其只执行父类的eat方法（可以对人类代码进行修改）。
# ⑥： 实例化一个狗类的对象，让其既执行父类的eat方法，又执行子类的eat方法。

 class Animal:
     def __init__(self,name,sex,age):
         self.name = name
         self.age = age
         self.sex = sex

     def eat(self):
         print('%s 在吃东西' % self.name)

 class Person(Animal):
     def __init__(self,name,sex,age,skin):
         super().__init__(name,sex,age)
         self.skin = skin
     def eat(self):
         print('人类正在吃饭')

 class Dog(Animal):
     def __init__(self,coat_colour):
         self.coat_colour = coat_colour
     def eat(self):

         print('狗狗正在吃饭')
 p1 = Person('李富贵','男',18,'黄皮肤')
 print(p1.__dict__)

2.

class E:
    def func(self):
        print('in E')

class A(E):

    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(A,B):
    def func(self):
        super(A,self).func()
        print('in C')
可以改动上上面代码，完成下列需求：
对C类实例化一个对象产生一个c1，然后c1.func()
c1 = C()
c1.func()
1, 让其执行C类中的func
2，让其执行A类中的func

3，让其执行B类中的func

4，让其既执行C类中的func，又执行A类中的func

5，让让其既执行C类中的func，又执行B类中的func

3.

# 3，下面代码执行结果是什么？为什么？
class Parent:
    def func(self):
        print('in Parent func')

    def __init__(self):
        self.func()

class Son(Parent):
    def func(self):
        print('in Son func')

son1 = Son()
in Son func

4.

class A:
    name = []

p1 = A()
p2 = A()
p1.name.append(1)
print(p1.name)
print(p2.name)
print(A.name)

# p1.name，p2.name，A.name 分别又是什么？为什么？
[1]
[1]
[1]

5.

class A:
    name = 'alex'

p1 = A()
p2 = A()
p1.name = 'wusir'
print(p1.name)
print(A.name)
#p1.name,A.name分别又是什么?
wusir
alex