WED.继承补充以及多态

最新推荐文章于 2023-03-10 01:22:31 发布

Yuppie_Disease

最新推荐文章于 2023-03-10 01:22:31 发布

阅读量140

点赞数

分类专栏：学习笔记

本文链接：https://blog.csdn.net/Cream_Bule/article/details/118737079

版权

学习笔记专栏收录该内容

60 篇文章 0 订阅

订阅专栏

WED.继承补充以及多态

属性查找

单继承背景下

class Foo:
    def f1(self):
        print('Foo.f1')
        
    def f2(self):
        print('Foo.f2')
        
        
class Bar(Foo):
    def f1(self):
        print('Bar.f1')
        
        
obj = Bar()
obj.f2()  # Foo.f2  Bar.f1
'''先从自身查找,自身没有就在父类查找,并非就近查找'''

'''调用父类f1'''
方法一
class Foo:
    def f1(self):
        print('Foo.f1')
        
    def f2(self):
        print('Foo.f2')
        Foo.f1(self)
        
        
class Bar(Foo):
    def f1(self):
        print('Bar.f1')
        
方法二
class Foo:
    def __f1(self):
        print('Foo.f1')
        
    def f2(self):
        print('Foo.f2')
        self.__f1()
        
class Bar(Foo):
    def f1(self):
        print('Bar.f1')

多继承背景下

继承原理

对于你定义的每一个类,Python 都会计算出一个方法解析顺序(MRO)列表,该 MRO 列表就是一个简单地所有基类的线性顺序列表
Python 会在 MRO 列表上从做到右开始查找基类,直到找到第一个匹配这个属性的类为止。而这个 MRO 列表的构造是通过一个 C3 线性化算法来实现的
- 类以及该类的对象访问属性都是参照该类的 MRO 列表

'''C3算法用以合并所有父类的 MRO 列表,并遵循三项准则'''
1.子类会先于父类被检查
2.多个父类会根据他们在列表中的顺序被检查
3.如果下一个类存在两个合法的选择,选择第一个父类

菱形继承

一个子类继承的多个父类,最终汇集到一个非 object 类上

class G:  # 在python2中，未继承object的类及其子类，都是经典类
    def test(self):
        print('from G')

class E(G):
    def test(self):
        print('from E')

class F(G):
    def test(self):
        print('from F')

class B(E):
    def test(self):
        print('from B')

class C(F):
    def test(self):
        print('from C')

class D(G):
    def test(self):
        print('from D')

class A(B,C,D):
    # def test(self):
    #     print('from A')
    pass

obj = A()
obj.test()

两种查找方式
- 深度优先
  - 当类是经典类时,查找属性不存在时，会按照深度优先的方式查找下去
```
查找顺序为:obj->A->B->E->G->C->F->D->object
```
- 广度优先
  - 当类是新式类时,查找属性不存在时，会按照深度广度的方式查找下去
```
查找顺序为:obj->A->B->E->C->F->D->G->object
```

非菱形继承

经典类和新式类,属性查找没有顺序要求

super()方法

调用super()会得到一个特殊的对象，该对象专门用来引用父类的属性，且严格按照MRO规定的顺序向后查找

class People():
    school = 'sh'

    def __init__(self, name, age, course=None):
        self.name = name
        self.age = age


class Student(People):

    def __init__(self, name, age, course):
        # People.__init__(self, name, age)
        # super(Student, self).__init__(name, age)  # python2
        super().__init__(name, age)  # python3

        self.course = course
        
        
obj = Student('egon',19, 'python')
print(obj.name)
print(obj.age)

'''super()是依赖于继承的，并且即使没有直接继承关系，super()仍然会按照MRO继续往后查找'''

多态与多态性

多态

多态指的是一类事物有多种形态

class Car:
    def door(self):
				pass
      
      
class BMW_i8(Car):
  	def door(self):
      	print('蝴蝶门')
        
        
class Audi_R8(Car):
  	def door(self):
      	print('平开门')
        
        
class Benz_SLS(Car):
  	def door(self):
      	print('哼哼哼')
        
# 实例化得到三个对象
>>>BMW = BMW_i8()
>>>Audi = Audi_R8()
>>>Benz = Benz_SLS()

多态性

多态性指的是可以在不用考虑对象具体类型的情况下而直接使用对象,这就需要在定义时,将对象的调用方法统一成一种: 例如 i8、R8、SLS都是车,但凡是车肯定有 door 方法,于是我们可以不用考虑他们三者具体是哪一种车型,而直接使用

>>>BMW = BMW_i8()
# 蝴蝶门
>>>Audi = Audi_R8()
# 平开门
>>>Benz = Benz_SLS()
# 鸥翼门

更进一步,我们可以定义一个统一的接口来使用

>>> def Door(Car):
        Car.door()
    
>>> Door(BMW)
# 蝴蝶门
>>> Door(Audi)
# 平开门
>>> Door(Benz)
# 鸥翼门

其实 Python 中一切皆对象,本身就支持多态性

# 我们可以在不考虑三者类型的情况下直接使用统计三个对象的长度
s.__len__()
l.__len__()
t.__len__()

# Python内置了一个统一的接口
len(s)
len(l)
len(t)


'''
多态性的好处在于增强了程序的灵活性和可扩展性，比如通过继承Car类创建了一个新的类，实例化得到的对象obj，可以使用相同的方式使用obj.door()
'''

多态类的继承

因此,多态性的本质在于不同的类中定义有相同的方法名，这样我们就可以不考虑类而统一用一种方式去使用对象，可以通过在父类引入抽象类的概念来硬性限制子类必须有某些方法名

import abc

# 指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod  # 该装饰器限制子类必须定义有一个名为talk的方法
    def talk(self):  # 抽象方法中无需实现具体的功能
        pass

class Cat(Animal):  # 但凡继承Animal的子类都必须遵循Animal规定的标准
    def talk(self):
        pass

cat=Cat()  # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化

鸭子类型

指看起来像、叫声像而且走起路来像鸭子,那么它就是鸭子。也就是说我们完全可以不依赖于继承,只需要制造出外观和行为相同对象,同样可以实现不考虑对象类型而使用对象,这就是 Python 所崇尚的"鸭子类型"

#二者看起来都像文件,因而就可以当文件一样去用，然而它们并没有直接的关系
class Txt: #Txt类有两个与文件类型同名的方法，即read和write
    def read(self):
        pass
    def write(self):
        pass

class Disk: #Disk类也有两个与文件类型同名的方法：read和write
    def read(self):
        pass
    def write(self):
        pass

组合

即一个对象拥有一个属性,这个属性的值是另外一个类的对象
- 继承满足什么是什么的关系
- 组合满足什么有什么的关系

class Course:
    def __init__(self,name,period,price):
        self.name=name
        self.period=period
        self.price=price
    def tell_info(self):
        print('<%s %s %s>' %(self.name,self.period,self.price))

class Date:
    def __init__(self,year,mon,day):
        self.year=year
        self.mon=mon
        self.day=day
    def tell_birth(self):
       print('<%s-%s-%s>' %(self.year,self.mon,self.day))

class People:
    school='清华大学'
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age

#Teacher类基于继承来重用People的代码，基于组合来重用Date类和Course类的代码
class Teacher(People): #老师是人
    def __init__(self,name,sex,age,title,year,mon,day):
        super().__init__(name,age,sex)
        self.birth=Date(year,mon,day) #老师有生日
        self.courses=[] #老师有课程，可以在实例化后，往该列表中添加Course类的对象
    def teach(self):
        print('%s is teaching' %self.name)


python=Course('python','3mons',3000.0)
linux=Course('linux','5mons',5000.0)
teacher1=Teacher('lili','female',28,'博士生导师',1990,3,23)

# teacher1有两门课程
teacher1.courses.append(python)
teacher1.courses.append(linux)

# 重用Date类的功能
teacher1.birth.tell_birth()

# 重用Course类的功能
for obj in teacher1.courses: 
    obj.tell_info()