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

cenylon 2020-05-08

一、继承

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、要找出类与类之间的继承关系,需要先抽象,再继承。抽象即总结相似之处,总结对象之间的相似之处得到类,总结类与类之间的相似之处就可以得到父类,如下图所示

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

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

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

 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

相关推荐