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

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

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

  • objectPython最基础类的名词,不需要翻译
  • 所有了定义时默认继承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

循序决定输出的结果

对继承概念的理解,类继承的构建,了解了objectPython中最基础的类

类属性的重载原则是最近覆盖原则

类方法的重载:重新重载的话类似类属性的重载;增量重载使用super()函数

多继承采用的方法是深度优先,从左至右

到此这篇关于Python面向对象编程之类的继承的文章就介绍到这了,更多相关Python类的继承内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Python 继承,重写,super()调用父类方法操作示例

    本文实例讲述了Python 继承,重写,super()调用父类方法操作.分享给大家供大家参考,具体如下: demo.py(继承,重写,super): # 父类 class Dog: def bark(self): print("汪汪叫") # 子类 继承 class XiaoTianQuan(Dog): def fly(self): print("我会飞") # 可以重写父类中的同名方法 def bark(self): # super().父类方法名 调用父类中的方

  • python子类如何继承父类的实例变量

    类型1:父类和子类的实例变量均不需要传递 class A(object): def __init__(self): self.name = "cui" def get_name(self): return self.name class B(A): def __init__(self): super(B,self).__init__() self.age = 12 b = B() 类型2:父类的实例变量不需要传递,子类的实例变量需要传递 class A(object): def __i

  • 浅谈Python类的单继承相关知识

    一.类的继承 面向对象三要素之一,继承Inheritance 人类和猫类都继承自动物类. 个体继承自父母,继承了父母的一部分特征,但也可以有自己的个性. 在面向对象的世界中,从父类继承,就可以直接拥有父类的属性和方法,这样就可以减少代码.多服用.子类可以定义自己的属性和方法 class Animal: def __init__(self,name): self._name = name def shout(self): print("{} shouts".format(self.__c

  • python面向对象之类的继承详解

    一.概述 面向对象编程 (OOP) 语言的一个主要功能就是"继承".继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展. 通过继承创建的新类称为"子类"或"派生类",被继承的类称为"基类"."父类"或"超类",继承的过程,就是从一般到特殊的过程.在某些 OOP 语言中,一个子类可以继承多个基类.但是一般情况下,一个子类只能有一个基类,要实

  • Python类的继承super相关原理解析

    看了网上许多关于super.mro.C3的介绍感觉没有一份很容易初学者理解的文档,直接看C3算法的话,比较难理解,也没必要,如果掌握一套规律的话,会轻松许多.我将网上这些博主的文章进行一个梳理总结,最后形成一套实用的关于super.mro.C3的理解介绍. 1.super super()是一种将子类与父类联系起来的一种方法,子类通过继承父类,可以使用父类的方法和属性,也可以自己定义属于自己的方法和属性.super方法主要用在多继承中,在单继承时直接调用父类方法即可 下面这个是SGD源码的一部分,

  • Python类继承和多态原理解析

    这篇文章主要介绍了python类继承和多态原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 现在属于是老年人的脑子,东西写着写着就忘了,东西记着记着就不知道了.之前学C++的时候就把类.对象这块弄得乱七八糟,现在是因为很想玩python,所以就看看python的类和对象. 就像说的,类有三个特征:封装.继承.多态. 1.封装:类封装了一些方法,可通过一定的规则约定方法进行访问权限. C++中的成员变量有public.private.pto

  • python类的继承链实例分析

    1.子类可以继承父类,同样,父类也可以继承自己的父类,一层一层地继承. class A: def have(self): print('I hava an apple') class B(A): pass class C(B): pass 2.如果想判断一个类别是否是另一个类别的子类别,可以使用内置函数issubclass(). >>> issubclass(C, A) True >>> issubclass(B, A) True >>> issubc

  • Python基础知识学习之类的继承

    一.继承的格式 类的继承格式如下,括号中的为父类名. class 类名(父类名): 代码 二.单继承 下面我们让Man继承自Master类,并调用继承的showSkill方法. class Master(): def __init__(self): self.skill='炒菜' def showSkill(self): print(self.skill) class Man(Master): pass man=Man() man.showSkill() 炒菜 三.多继承 我们可以在括号中写入多

  • 详细总结Python类的多继承知识

    一.Python不同版本的类 Python2.2之前是没有共同的祖先的,之后引入Object类,它是所有类的共同祖先类Object Python2中为了兼容,分为古典类(旧式类)和新式类 Python3中全部都是新式类 新式类都是继承自Object的,新式类可以使用super #古典类在python2.x中运行 class A: pass print(dir(A)) # ['__doc__', '__module__'] print(A.__bases__) # () a = A() print

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

    目录 1.对继承的理解 2.类继承的构建 3.Python中最基础的类 4.ython类的重载 4.1 属性重载 4.2 方法重载 5.类的多继承 1.对继承的理解 继承(Inheritance) :代码复用的高级抽象 继承是面向对象设计的精髓之一 实现了以类为单位的高级抽象级别代码复用 继承是新定义类能够几乎完全使用原有类属性与方法的过程 不管是基类还是派生类,只是一种继承说法,这都是普通的Python类 也可以按子类.父类和超类划分. 最基础的类是基类,经过一次继承得出派生类,还可以再一次继

  • 举例讲解Python面向对象编程中类的继承

    python创建一个类很简单只需要定义它就可以了. class Cat: pass 就像这样就可以了,通过创建子类我们可以继承他的父类(超类)的方法.这里重新写一下cat class Cat: name = 'cat' class A(Cat): pass print A.name # cat 经典类 我们也可以这样,让A多继承. class Cat: name = 'cat' class Dog: name = 'dog' class A(Cat, Dog): pass print A.nam

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

    目录 Python  面向对象编程的三大特性之继承 一.继承 1.继承的实际栗子 2.继承的好处 3.继承的使用场景 4.继承有几种? 5.Python 中继承的简单语法 二.不使用继承.使用继承的区别 1.需求背景 2.不使用继承 2.使用继承 三.继承的传递性 1.什么是传递性 四.继承和抽象 1.继承的重点 Python  面向对象编程的三大特性之继承 一.继承 继承也是面向对象编程三大特性之一 继承是类与类的一种关系 定义一个新的 class 时,可以从某个现有的 class 继承 新的

  • Python面向对象编程基础解析(一)

    1.什么是面向对象 面向对象(oop)是一种抽象的方法来理解这个世界,世间万物都可以抽象成一个对象,一切事物都是由对象构成的.应用在编程中,是一种开发程序的方法,它将对象作为程序的基本单元. 2.面向对象与面向过程的区别 我们之前已经介绍过面向过程了,面向过程的核心在'过程'二字,过程就是解决问题的步骤,面向过程的方法设计程序就像是在设计一条流水线,是一种机械式的思维方式 优点:复杂的问题简单化,流程化 缺点:扩展性差 主要应用场景有:Linux内核,git,以及http服务 面向对象的程序设计

  • Python面向对象编程中的类和对象学习教程

    Python中一切都是对象.类提供了创建新类型对象的机制.这篇教程中,我们不谈类和面向对象的基本知识,而专注在更好地理解Python面向对象编程上.假设我们使用新风格的python类,它们继承自object父类. 定义类 class 语句可以定义一系列的属性.变量.方法,他们被该类的实例对象所共享.下面给出一个简单类定义: class Account(object): num_accounts = 0 def __init__(self, name, balance): self.name =

  • 关于Python面向对象编程的知识点总结

    前言 如果你以前没有接触过面向对象的编程语言,那你可能需要先了解一些面向对象语言的一些基本特征,在头脑里头形成一个基本的面向对象的概念,这样有助于你更容易的学习Python的面向对象编程. 接下来我们就来了解关于Python面向对象编程的知识点吧. 类与实例 类是对象的定义,而实例是"真正的实物",它存放了类中所定义的对象的具体信息. 类.属性和方法命名规范 类名通常由大写字母打头.这是标准惯例,可以帮助你识别类,特别是在实例化过程中(有时看起来像函数调用).还有,数据属性(变量或常量

  • 详解Python:面向对象编程

    面向过程的程序设计把计算机程序视为一系列的命令集合,即一组函数的顺序执行.为了简化程序设计,面向过程把函数继续切分为子函数,即把大块函数通过切割成小块函数来降低系统的复杂度 python和java都是面向对象的语言.面向对象编程的特点数据封装.继承和多态 1.类和实例 面向对象最重要的概念就是类(Class)和实例(Instance),必须牢记类是抽象的模板,比如Student类,而实例是根据类创建出来的一个个具体的"对象",每个对象都拥有相同的方法,但各自的数据可能不同. 在pyth

  • Python 面向对象之封装、继承、多态操作实例分析

    本文实例讲述了Python 面向对象之封装.继承.多态操作.分享给大家供大家参考,具体如下: 封装.继承.多态 是面向对象的3大特性 为啥要封装 好处 在使用面向过程编程时,当需要对数据处理时,需要考虑用哪个模板中哪个函数来进行操作,但是当用面向对象编程时,因为已经将数据存储到了这个独立的空间中,这个独立的空间(即对象)中通过一个特殊的变量(class)能够获取到类(模板),而且这个类中的方法是有一定数量的,与此类无关的将不会出现在本类中,因此需要对数据处理时,可以很快速的定位到需要的方法是谁

  • Python面向对象编程基础实例分析

    本文实例讲述了Python面向对象编程基础.分享给大家供大家参考,具体如下: 1.类的定义 Python中类的定义与对象的初始化如下,python中所有类的父类是object,需要继承. 由于Python是动态语言,因此可以直接为对象添加属性并赋值而不必在类定义中声明 class Person(object): # 定义一个Person类 pass p = Person() # 初始化一个Person对象 p.name="xiaoming" # 对象属性赋值 Python的类初始化方法

  • 浅析Python面向对象编程

    概述 很多人接触Python,都是从爬虫开始,其实很多语言都可以做爬虫,只是Python相对其他语言来说,更加简单而已.但是Python并不止于爬虫,在人工智能,科学计算等方面的应用更加广泛.古人云:万丈高楼平地起,要想有长足的发展,打好基础很重要,本文主要讲解Python的面向对象相关知识,仅供学习分享使用,如有不足之处,还请指正. 面向对象的特征 类:用来描述相同事物的特征的集合,如:Person 类,表示人,具有人的属性和特征. 对象:通过类定义的具体的实例,如:zhangsan 表示一个

随机推荐