Python的面向对象的三大特性之继承

一、继承

1、什么是继承  继承是一种创新类的方式，在python中，  新建的类可称子类或者派生类，父类称为基类或者超类  子类会继承父类所有属性需要注意的是：    python支持多继承    新建的类可以继承一个或者多个父类

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

# 查看子类调用的父类
print(Sub1.__bases__) # (<class ‘__main__.Parent1‘>,)
print(Sub2.__bases__) # (<class ‘__main__.Parent1‘>, <class ‘__main__.Parent2‘>)

python的多继承  优点：子类可以同时继承多个父类的属性，最大限度的重用代码。  缺点：      1、违背人的思维习惯，继承表达的是一种什么“是”什么的关系。      2、代码可读性会变差　　　 3、不建议使用多继承，扩展性变差，如果真的涉及到一个子类不可避免的要重用多个父类的属性，应该使用Mixins

单继承：继承表达的是一种什么“是”什么的关系  人类  动物类  共同的特点：吃，睡，跑，叫，也就是说人是动物多继承：就不能像单继承那样，一个事物不能同时是多个事物，逻辑冲突
class A:
    pass
class B(A):
    x = 222
class C(B):
    pass
class D(C):
    pass

print(D.x) # 222 先去D找，再去C找，再去B找

# ps1：在python2中有经典类和新式类之分
# 新式类：继承了object类的子类，以及该子类的子类
# 经典类：没有继承object类的子类，以及该子类的子类子子类
# 总结：object类是python内置的类，也就是所有类的超类
"""
>>> class Foo:  # 经典类
...     pass
...
>>> Foo.__bases__
()
>>> class Bar(object):  # 新式类
...     pass
...
>>> Bar.__bases__
(<type ‘object‘>,)
>>>
"""
# ps2:在python3中有没有经典类和新式类之分?
#       在python3之中没有继承任何类，那么会默认继承object类，所以python3中所有的类都是新式类
print(Parent1.__bases__)  # (<class ‘object‘>,)
print(Parent2.__bases__)  # (<class ‘object‘>,)

# 所以思考如何让python3中的类在python2中兼容？加入（object）
class Parent3(object):  # 兼容python2
    pass

2、为何要用继承？  用来解决代码冗余，      类是解决对象之间代码冗余，      继承是解决类之间代码冗余。

class Parent4:
    x = 1
class Sub4(Parent4):
    y = 2

print(Sub4.x,Sub4.y) # 1 2

 3、要找出类与类之间的继承关系，需要先抽象，再继承。抽象即总结相似之处，总结对象之间的相似之处得到类，总结类与类之间的相似之处就可以得到父类，如下图所示

 基于抽象的结果，我们就找到了继承关系

 4、继承的使用

# 思考一下找到学生和老师的共同之处：
# 示范1：基于类与类之间存在冗余问题

# 选课系统
# 定义学生类
class Student:
    school = ‘OLDBOY‘
    # 定义学生属性
    def __init__(self,stu_id,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    # 定义学生功能
    def choose_course(self):
        print(‘%s 正向选课‘ % self.name)

# 定义老师类
class Teacher:
    school = ‘OLDBOY‘

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

    def score(self):
        print(‘老师 %s 正在给学生打分‘ % self.name)

# 派生的三种情况：新建，修改，扩展

# 提取出共有的属性
class OldboyPeople:
    school = ‘OLDBOY‘
    # 定义共有属性
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

# 选课系统
# 定义学生类
class Student(OldboyPeople):

    # 派生之一：新建一个功能
    def choose_course(self):
        print(‘%s 正向选课‘ % self.name)

    # 派生之二：修改
    school = ‘派生之二修改OLDBOY学校名‘

# 实例话学生
stu_obj = Student(‘lili‘,18,‘female‘)
print(stu_obj.__dict__)  # {‘name‘: ‘lili‘, ‘age‘: 18, ‘sex‘: ‘female‘}
print(stu_obj.school)  # 派生前OLDBOY 派生后运行结果：派生之二修改OLDBOY学校名
stu_obj.choose_course()  # lili 正向选课

"""
    对象本身,lsj‘,18,‘male‘,3000,2
init中(self,name,age,sex,salary,level)
"""
class Teacher(OldboyPeople):
    # 派生之三：扩展
    def __init__(self,name,age,sex,salary,level):
        # 指名道姓的跟父类要init这个方法（name,age,sex）
        OldboyPeople.__init__(self,name,age,sex)
        self.salary = salary
        self.level = level

    def score(self):
        print(‘老师 %s 正在给学生打分‘ % self.name)

tea_obj = Teacher(‘lsj‘,18,‘male‘,3000,2)
# 派生之三前运行结果：TypeError: __init__() takes 4 positional arguments but 6 were given

print(tea_obj.__dict__)
# 派生之三后运行结果：{‘name‘: ‘lsj‘, ‘age‘: 18, ‘sex‘: ‘male‘, ‘salary‘: 3000, ‘level‘: 2}

print(tea_obj.school)  # OLDBOY
tea_obj.score()  # 老师 lsj 正在给学生打分

5、单继承下属性的查找顺序

# 单继承背景下的属性查找# 示范一class Foo:
    def f1(self):
        print(‘Foo.f1‘)
    def f2(self):
        print(‘Foo.f2‘)
        self.f1()  # obj.f1()

class Bar(Foo):
    def f1(self):
        print(‘Bar.f1‘)

obj = Bar()
obj.f2()
# 运行结果：Foo.f2  Bar.f1
# 为什么是这样的结果：不是就近查找

# 单继承背景下的属性查找
# 需求必须调用Foo类下的f1该怎么办？# 示范一class Foo:
    def f1(self):
        print(‘Foo.f1‘)
    def f2(self):
        print(‘Foo.f2‘)
        Foo.f1(self) # 调用当前类中的f1，运行结果：Foo.f1
        self.f1()  # obj.f1()

class Bar(Foo):
    def f1(self):
        print(‘Bar.f1‘)

obj = Bar()
obj.f2()
# 运行结果：Foo.f2  Bar.f1
# 为什么是这样的结果：不是就近查找

# 示范二 
class Foo:
    # 使用隐藏属性
    def __f1(self):   # _Foo__f1
        print(‘Foo.f1‘)
    def f2(self):
        print(‘Foo.f2‘)
        self.__f1()  # self._Foo__f1

class Bar(Foo):
    def __f1(self):  # _Bar__f1
        print(‘Bar.f1‘)

obj = Bar()
obj.f2()
# 运行结果：Foo.f2  Foo.f1