面向对象进阶1

Posted hades123

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面向对象进阶1相关的知识,希望对你有一定的参考价值。

类的继承

什么是继承

继承就是新建一个类的方式,新建的类我们叫子类,被继承的类称为父类

在现实生活中,子女继承了父母的基因,遗产,所以子女会拥有父母的部分特征

而在python中,子类继承父类就是子类完全拥有父类所具备的属性及技能

为什么要继承

比如我现在定义一个动物类,这个动物类拥有名字,身高,体重

然后我再定义一个人类,这个人也有名字,身高,体重再加其他的属性技能

我再定义一个狗类,也有名字,身高,体重再加其他的属性技能

class Animal:
    
    def __init__(self,name,height,weight):
        self.name = name
        self.height = height
        self.weight = weight
        
        
class People:
    
    def __init__(self,name,height,weight,age):
        self.name = name
        self.height = height
        self.weight = weight
        self.age = age
        
        
class Dog:
    
    def __init__(self,name,height,weight,color):
        self.name = name
        self.height = height
        self.weight = weight
        self.color = color
  • 现在我们看上面的代码,会发现我们一直在写重复的代码,像人和狗都是属于动物类,他们在某些方面是具有动物共同特征的,所以可以继承动物类的特征
class Animal:
    
    def __init__(self,name,height,weight):
        self.name = name
        self.height = height
        self.weight = weight
        
        
class People(Animal):
    
    def __init__(self,name,height,weight,age):
        Animal.__init__(self,name,height,weight)
        self.age = age
        
        
class Dog(Animal):
    
    def __init__(self,name,height,weight,color):
        Animal.__init__(self,name,height,weight)
        self.color = color
  • 这样看来我们的代码就精简的了汗多

所以类的继承可以减少代码的冗余

对象的继承

  • 使用__bases__可以获得对象继承的类
print(People.__bases__)
print(Dog.__bases__)
(<class '__main__.Animal'>,)
(<class '__main__.Animal'>,)
  • 在Python3中如果一个类没有继承任何类,则默认继承object类

  • 在Python2中如果一个类没有继承任何类,不会继承object类

print(Animal.__bases__)
(<class 'object'>,)

类的查找顺序

  • 对象查找属性的顺序:对象自己--》对象的类--》父类--》父类
class Foo:
    def f1(self):
        print('Foo.f1')

    def f2(self):
        print('Foo.f2')
        self.f1()   # 此时的self.f1()代表了obj.f1()


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


# 对象查找属性的顺序:对象自己-》对象的类-》父类-》父类。。。
obj = Bar()  # self是obj本身,即找到Bar的f1()
obj.f2()
Foo.f2
Bar.f1

类的派生

派生:子类中新定义的属性的这个过程叫做派生,并且需要记住子类在使用派生的属性时始终以自己的为准

派生方法一

直接访问某一个函数,这种方式与继承无关

class Animal:
    
    def __init__(self,name,height,weight):
        self.name = name
        self.height = height
        self.weight = weight
        
        
class People:
    
    def __init__(self,name,height,weight,age):
        Animal.__init__(self,name,height,weight)
        self.age = age   # 派生
        
        
class Dog(Animal):
    
    def __init__(self,name,height,weight,color):
        super().__init__(name,height,weight)
        self.color = color # 派生

派生方法二

  • 严格以来继承属性查找关系

  • super()会得到一个特殊的对象,该对象就是专门用来访问父类中的属性的(按照继承的关系)

  • super().__init__(不用为self传值)

  • super的完整用法是super(自己的类名,self),在python2中需要写完整,而python3中可以简写为super()

上面的Dog就是使用了方法二来进行的

类的组合

类的组合就是某一个类的对象具有一个属性,该属性的值指向另一个类的对象

优点:用来解决类与类之间代码的冗余

# 定义课程类
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 OldBoyPeople:
    school = 'oldboy'
    
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
        
# 定义老师类        
class OldBoyTeacher(OldBoyPeople):
    def __init__(self,name,age,gender,level):
        super().__init__(name,age,gender)
        self.level = level

    def score(self,student,num):
        print(f'老师self.name为student.name的<student.course.name>课程打了num分')
        
# 定义学生类        
class OldBoyStudent(OldBoyPeople):
    
    def __init__(self,name,age,gender,stu_id):
        super().__init__(name,age,gender)
        self.stu_id = stu_id
        
    def choose_course(self,course):
        self.course = course
        print(f'self.name选择了<course.name>课程')
# 创建课程
python = Course('Python全栈开发','6个月',25000)
python.tell_info()
        课程名:Python全栈开发
        课程周期:6个月
        课程价钱:25000
linux = Course('Linux运维','6个月',20000)
linux.tell_info()
        课程名:Linux运维
        课程周期:6个月
        课程价钱:20000
# 创建老师
tec = OldBoyTeacher('hades',27,'male',1)
print(tec.__dict__)
'name': 'hades', 'age': 27, 'gender': 'male', 'level': 1
# 创建学生
stu = OldBoyStudent('Bonnie',16,'female','00001')
print(stu.__dict__)
'name': 'Bonnie', 'age': 16, 'gender': 'female', 'stu_id': '00001'
  • 组合
stu.choose_course(python)
stu.course.tell_info()
Bonnie选择了<Python全栈开发>课程

        课程名:Python全栈开发
        课程周期:6个月
        课程价钱:25000
tec.score(stu,98)
老师hades为Bonnie的<Python全栈开发>课程打了98分

菱形继承问题

类的分类

新式类

  • 继承了object类以及该类的子类,都是新式类
  • Python3中所有的类都是新式类

经典类

  • 没有继承了object类以及该类的子类,都是经典类
  • 只有Python2有经典类,因为Python2中的object类要手动进行添加

菱形继承问题

在python中子类可以继承多个父类,如A(B,C,D)

如果继承关系为非菱形结构,则会按照(B,C,D)的顺序依次寻找,如果找不到就会报错

菱形继承就是子类同时继承多个父类,而多个父类又同时继承了同一个父类

这样就会有一个查找顺序的问题,属性查找顺序有两种:

  • 经典类下:深度优先,也就是一条线找到底
  • 新式类:广度优先,不找多各类最后继承的同一个类,直接去找下一个父类

技术图片

技术图片

class G:
    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 D(G):
    def test(self):
        print('from D')
        
class C(F):
    def test(self):
        print('from C')
        
class B(E):
    def test(self):
        print('from B')
        
class A(B,C,D):
    def test(self):
        print('from A')
        
obj = A()

我们可以通过__mro__算法进行打印查找顺序

print(A.__mro__)
(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.F'>, <class '__main__.D'>, <class '__main__.G'>, <class 'object'>)
for i in A.__mro__:
    print(i)
<class '__main__.A'>
<class '__main__.B'>
<class '__main__.E'>
<class '__main__.C'>
<class '__main__.F'>
<class '__main__.D'>
<class '__main__.G'>
<class 'object'>

为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。

而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

  1. 子类会先于父类被检查

  2. 多个父类会根据它们在列表中的顺序被检查

  3. 如果对下一个类存在两个合法的选择,选择第一个父类

类的多态与多态性

多态

多态指的是一类事物具有多种形态,即一个抽象的类具有多个子类,因而多态的概念依赖于继承

  1. 数据类型有多种形态:字符串,列表,整型
  2. 动物有多种形态:人,猪,狗
class Animal:
    def communicate(self):   # 子类约定俗称的必须实现这个方法
        print('动物类会交流')
        
class People(Animal):
    def communicate(self):
        print('人类通过语言交流')
        
class Dog(Animal):
    def communicate(self):
        print('狗通过"汪汪汪"进行交流')
        
class Pig(Animal):
    def communicate(self):
        print('猪通过"哼哼哼"进行交流')
peo1 = People()
dog1 = Dog()
pig1 = Pig()

peo1.communicate()
dog1.communicate()
pig1.communicate()
人类通过语言交流
狗通过"汪汪汪"进行交流
猪通过"哼哼哼"进行交流

但是总有人不遵守规则,想搞例外,所以我们可以通过@abc.abstractmethod方法进行强制要求,如果子类没有这个功能则会报错

import abc

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def communicate(self):   # 子类约定俗称的必须实现这个方法
        print('动物类会交流')
        
class People(Animal):
    def communicate(self):
        print('人类通过语言交流')
        
class Dog(Animal):
    def communicate(self):
        print('狗通过"汪汪汪"进行交流')
        
class Pig(Animal):
#     def communicate(self):
#         print('猪通过"哼哼哼"进行交流')
    pass 

peo2 = People()
peo2.communicate()
dog2 = Dog()
dog2.communicate()
pig2 = Pig() # 报错
人类通过语言交流
狗通过"汪汪汪"进行交流



---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-76-4c019fadd2e5> in <module>
     23 dog2 = Dog()
     24 dog2.communicate()
---> 25 pig2 = Pig() # 报错


TypeError: Can't instantiate abstract class Pig with abstract methods communicate

多态性

多态性是指具有不同功能的函数可以使用相同的函数名,这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性:向不同的对象发送同一条消息,不同的对象在接收时会产生不同的行为(即方法)。也就是说,每个对象可以用自己的方式去响应共同的消息。所谓消息,就是调用函数,不同的行为就是指不同的实现,即执行不同的函数。

def func(obj):
    obj.communicate()
    
func(peo1)
func(dog1)
func(pig1)
人类通过语言交流
狗通过"汪汪汪"进行交流
猪通过"哼哼哼"进行交流
func(peo2)
func(dog2)
人类通过语言交流
狗通过"汪汪汪"进行交流

综上可以说,多态性是一个接口(函数func)的多种实现(如obj.communicate())

多态性的好处

  1. 增加了程序的灵活性:以不变应万变,不论对象千变万化,使用者都是同一种形式去调用,如func(animal)

  2. 增加了程序额可扩展性:通过继承Animal类创建了一个新的类,使用者无需更改自己的代码,还是用func(animal)去调用

以上是关于面向对象进阶1的主要内容,如果未能解决你的问题,请参考以下文章

面向对象——面向对象进阶

面向对象(进阶)

python(24)- 面向对象进阶

python面向对象进阶版

Python中面向对象初识到进阶

java学习---面向对象进阶