首页 > 资讯 > 后端开发 > Python >Python面向对象编程之类的继承

929

分享到

Python面向对象编程之类的继承

2024-04-02 19:04:59 929人浏览泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录1、对继承的理解2、类继承的构建3、python中最基础的类4、ython类的重载4.1 属性重载4.2 方法重载5、类的多继承1、对继承的理解继承（Inheritance）

1、对继承的理解

继承（Inheritance）：代码复用的高级抽象

继承是面向对象设计的精髓之一
实现了以类为单位的高级抽象级别代码复用
继承是新定义类能够几乎完全使用原有类属性与方法的过程

不管是基类还是派生类，只是一种继承说法，这都是普通的Python类

也可以按子类、父类和超类划分。

最基础的类是基类，经过一次继承得出派生类，还可以再一次继承，又得出一个派生类；现在最基础的类和第一次继承出来的派生类是父类与子类的关系，派生出来的类在最后一次派生出来的类也是父类与子类的关系，而最基本的类和最后一个派生类属于超类和子类的关系

派生类不仅可以继承一个基类，也可以继承多个基类，这就是所说的多继承的概念

2、类继承的构建

类继承的时候在定义的时候声明继承关系，语法结构如下


class <派生类名>(<基类名>):  # 基类名可以带路径:ModuleNama.BaseClassName
    def __init__(self, <参数列表>):
        <语句块>
    ...

派生类可以直接使用基类的属性和方法

基类的属性基本等于定义在派生类中
派生类可以直接使用基类的类属性、实例属性
派生类可以直接使用基类的各种方法
使用基类的类方法和类属性时，要用基类的类名调用

实例代码：


class TestClass:
    def __init__(self, number):
        self.sum_number = 0
        for i in range(number + 1):
            self.sum_number += i

    def sum_num(self):
        return self.sum_number


class HumanNameClass(TestClass):
    def double_sum(self):
        return self.sum_number * 2  # 对基类属性的使用


value1 = HumanNameClass(100)
print(value1.sum_num())  # 5050  # 对基类实例方法的使用
print(value1.double_sum())  # 10100  # 对派生类实例方法的使用

Python中有两个与继承关系判断有关的函数

接上面的代码，


print(isinstance(value1, TestClass))  # True
print(isinstance(value1, HumanNameClass))  # True
print(isinstance(value1, int))  # False
print(issubclass(HumanNameClass, TestClass))  # True
print(issubclass(TestClass, HumanNameClass))  # False

3、Python中最基础的类

因为Python中万物皆对象，任何一个类也是对象、Python的所有数据类型也对象；Python语言提供所有类的最基础类是object。

object是Python最基础类的名词，不需要翻译
所有了定义时默认继承object
保留属性和保留方法本质上是object类的属性和方法

示例代码：


print(object.__name__)  # 打印object的名字  # object
print(object.__bases__)  # 打印object所继承的类名称  # ()
print(object.__doc__)  # 打印object类描述  # The most base type
print(object.__module__)  # 打印object所在模块的名称  # builtins
print(object.__class__)  # object所对应的类信息  # <class 'type'>

Python对象的三个要素：

标识 identity：对象一旦构建不会改变，用id()获得，一般是内存地址
类型 type：对象的类型，用type()获得
值 value：分为可变mutable与不可变immutable两种

两个和基础类有关的Python内置功能

函数/关键字	描述
id(x)	返回x的标识。CPython 中 id() 函数用于获取对象的内存地址。
x is y	判断x和y的标识是否相等，返回True或False，不判断值

4、ython类的重载

重载是派生类对基类属性或方法的在定义

属性重载：派生类定义并使用了与基类相同名称的属性
方法重载：派生类定义并使用了与基类相同名称的方法

4.1 属性重载

属性重载采用就近覆盖原则，重载无需特殊标记。方法步骤

优先使用派生类重定义的属性和方法
然后寻找基类的属性和方法
在寻找超类的属性和方法

实例代码:


class TestClass:
    text = "这是基类的类属性"

    def __init__(self, number):
        self.sum_number = 0
        for i in range(number + 1):
            self.sum_number += i

    def sum_num(self):
        return self.sum_number


class HumanNameClass(TestClass):
    text = "这是派生类的类属性"  # 类属性重载

    def __init__(self, number):
        self.sum_number = 1000  # 实例属性重载

    def double_sum(self):
        return self.sum_number * 2


value1 = HumanNameClass(100)
print(TestClass.text)  # 这是基类的类属性
print(value1.text)  # 这是派生类的类属性
print(value1.sum_num())  # 1000

4.2 方法重载

方法重载是派生类对基类方法的在定义；分为完全重载和增量重载

完全重载：派生类完全重定义与基类相同名称的方法

直接在派生类中定义同名方法即可

示例代码：


class TestClass:
    def __init__(self, number):
        self.sum_number = 0
        for i in range(number + 1):
            self.sum_number += i

    def sum_num(self):
        return self.sum_number


class HumanNameClass(TestClass):

    def sum_num(self):  # 方法的重建
        return self.sum_number * 2


value1 = HumanNameClass(100)
print(value1.sum_num())  # 10100

增量重载：派生类扩展定义与基类相同名称的方法，语法结构


class <派生类名>(<基类名>):
    def <方法名>(self, <参数列表>):
        super().<基类方法名>(<参数列表>)
        ...

增量重载使用super()函数

示例代码：


class TestClass:
    def test_text(self):
        print("这是基类的方法")


class TestClass1(TestClass):
    def test_text(self):  # 增量重载
        super().test_text()
        print("这是新增的方法里面的语句")


doc1 = TestClass()
doc2 = TestClass1()
print(doc1.test_text())
print(doc2.test_text())
'''
---输出结果---
这是基类的方法
None   # 因为函数没有返回值
这是基类的方法
这是新增的方法里面的语句
None  # 因为函数没有返回值

'''

5、类的多继承

多继承的构建是在定义时声明继承关系，语法结构


class <类名>(<基类名1>, <基类名2>,..., <基类名N>):  # 基类名可以带路径:ModuleNama.BaseClassName
    def __init__(self, <参数列表>):
        <语句块>
    ...

Python中多继承采用深度优先，从左至右的方法。所谓深度优先从左至右就是先从最左边开始找，找到他的基类，如果基类没有在往上面找，直到最基础的object类时还没有找到，才往右开始寻找。

所有属性和方法的使用按照“深度优先从左至右”的方式选取

构造函数也参照上述原则，super()也参照上述原则

多个基类的顺序是关键

示例代码：


class Test1:
    def test(self):
        text = "这是基类1"
        return text


class Test2:
    def test(self):
        text = "这是基类2"
        return text


class Test3(Test1, Test2):
    pass


class Test4(Test2, Test1):
    pass


value1 = Test3()
value2 = Test4()
print(value1.test())  # 这是基类1
print(value2.test())  # 这是基类2