Python 类继承,__bases__, __mro__, super

Python--class的super方法、多重继承和MRO python中的类是可以多继承的 python中的类方法和对象方法通过super调用父类的方法 上面两句话是对python class的一般认识,但其实第二句是错的。 阅读详情

Python是面向对象的编程语言,也支持类继承。

>>> class Base:

... pass

...

>>> class Derived(Base):

... pass

  

这样就定义了两个类,Derived继承了Base。issubclass(a,b)可以测试继承关系:

>>> issubclass(Derived, Base)

True

  

在Python中,每个类有一个__bases__属性,列出其基类

>>> Derived.__bases__

(<class '__main__.Base'>,)

  

同C++,Python支持多重继承;

>>> class Derived2(Derived,Base):

... pass

...

Derived2继承了Derived和Base(实际中不会这么写)

>>> Derived2.__bases__

(<class '__main__.Derived'>, <class '__main__.Base'>)

  

这里,Derived,和Base的顺序不能搞反

>>> class Derived2(Base, Derived):

... pass

...

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: Cannot create a consistent method resolution

order (MRO) for bases Derived, Base

  

插一段C++

C++代码

class Base{

};

  

class Derived: public Base{

};

  

class Derived2: public Base, public Derived{

};

  

int main(){

}

mulit_inherit.cc:7:7: warning: direct base 'Base' inaccessible in 'Derived2' due to ambiguity [enabled by default]

class Derived2: public Base, public Derived{

^

mulit_inherit.cc:7:7: warning: direct base 'Base' inaccessible in 'Derived2' due to ambiguity [enabled by default]

class Derived2: public Derived, public Base{

^

可以见,C++并没有限制书写顺序。warning指示了Derrived2中不能访问Base

Derived2 d;

Base &b = d;

error: 'Base' is an ambiguous base of 'Derived2'

Base &b = d;

^

  

回到Python继承,Derived2是Derived的子类,也是Base的子类

>>> issubclass(Derived2, Base)

True

>>> issubclass(Derived2, Derived)

True

  

__bases__类似于Javascript中Object对象的__proto__,是实现继承的基础,不同在于:__bases__不可修改,而且__bases__是类的属性而不是对象属性(Javascript是基于对象的语言);

  

>>> d = Derived2()

>>> d.__bases__

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

AttributeError: 'Derived2' object has no attribute '__bases__'

>>> d.__class__

<class '__main__.Derived2'>

>>> d.__class__.__bases__

(<class '__main__.Derived'>, <class '__main__.Base'>)

  

对象的__class__属性指明了所属类型;

>>> [].__class__

<class 'list'>

>>> ().__class__

<class 'tuple'>

>>> 1.__class__

File "<stdin>", line 1

1.__class__

^

SyntaxError: invalid syntax

  

>>> type(1)

<class 'int'>

在Python中1,是对象还是基本类型?

  

__mro__

__mro__给出了method resolution order,即解析方法调用的顺序。

  

>>> Derived.__mro__

(<class '__main__.Derived'>, <class '__main__.Base'>, <class 'object'>)

>>> Derived2.__mro__

(<class '__main__.Derived2'>, <class '__main__.Derived'>, <class '__main__.Base'>, <class 'object'>)

  

看上去和__bases__相像,只是最后面多了个<class 'object'>

  

super

super函数可以用于调用父类的方法,而后者可能被子类覆盖;类似在java中的作用,但使用起来更复杂些。

>>> class Base:

... pass

...

>>> class Derived(Base):

... pass

...

>>> class Derived2(Derived)

File "<stdin>", line 1

class Derived2(Derived)

^

SyntaxError: invalid syntax

>>> class Derived2(Derived):

... pass

...

>>> d = Derived2()

>>> super(Derived2, d)

<super: <class 'Derived2'>, <Derived2 object>>

>>> super(Derived, d)

<super: <class 'Derived'>, <Derived2 object>>

>>> super(Base, d)

<super: <class 'Base'>, <Derived2 object>>

  

参考https://docs.python.org/2/library/functions.html#super,

super(type[, object-or-type])

Return a proxy object that delegates method calls to a parent or sibling class of type. This is useful for accessing inherited methods that have been overridden in a class. The search order is same as that used by getattr() except that the type itself is skipped.

  

The __mro__ attribute of the type lists the method resolution search order used by both getattr() and super().

  

>>> isinstance(super(Base, d), Base)

False

>>> isinstance(super(Derived, d), Base)

False

代理对象并不是类层次中某个类的实例!

  

结合多重继承来理解下__mro__和super

class A:

def __init__(self):

print('enter __init__@A')

super(A,self).__init__()

print('exit __init__@A')

class B(A):

def __init__(self):

print('enter __init__@B')

super(B,self).__init__()

print('exit __init__@B')

class C(A):

def __init__(self):

print('enter __init__@C')

super(C,self).__init__()

print('exit __init__@C')

class D(A):

def __init__(self):

print('enter __init__@D')

super(D,self).__init__()

print('exit __init__@D')

class E(B,C):

def __init__(self):

print('enter __init__@E')

super(E,self).__init__()

print('exit __init__@E')

class F(E,D):

def __init__(self):

print('enter __init__@F')

super(F,self).__init__()

print('exit __init__@F')

  

if __name__ == '__main__':

A()

print(A.__mro__)        

B()

print(B.__mro__)        

C()

print(C.__mro__)        

D()

print(D.__mro__)        

E()

print(E.__mro__)        

F()

print(F.__mro__)

运行结果

enter __init__@A

exit __init__@A

(<class '__main__.A'>, <class 'object'>)

enter __init__@B

enter __init__@A

exit __init__@A

exit __init__@B

(<class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

enter __init__@C

enter __init__@A

exit __init__@A

exit __init__@C

(<class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

enter __init__@D

enter __init__@A

exit __init__@A

exit __init__@D

(<class '__main__.D'>, <class '__main__.A'>, <class 'object'>)

enter __init__@E

enter __init__@B

enter __init__@C

enter __init__@A

exit __init__@A

exit __init__@C

exit __init__@B

exit __init__@E

(<class '__main__.E'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

enter __init__@F

enter __init__@E

enter __init__@B

enter __init__@C

enter __init__@D

enter __init__@A

exit __init__@A

exit __init__@D

exit __init__@C

exit __init__@B

exit __init__@E

exit __init__@F

(<class '__main__.F'>, <class '__main__.E'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>)

观察到,super的执行路径和类的__mro__列举的类顺序吻合;而__mro__的顺序可以看作是深搜的结果

A

/ | \

B C D

\ / /

E /

\ /

F

class E(B, C)中,B和C不是基-派生类关系,E.__mro__中B在C之前,需要注意;

  

多态

  

>>> class Base:

... def sayHello(self):

... print("Base says hello")

...

>>> class Derived(Base):

... pass

...

>>> d = Derived()

>>> d.sayHello()

Base says hello

Derived重写sayHello

>>> class Derived(Base):

... def sayHello(self):

... print("Derived says hello");

...

>>> d = Derived()

>>> d.sayHello()

Derived says hello

  

与参数默认值结合(联想起了C++)

>>> class Base:

... def sayHello(self, str="Base"):

... print("Base says: " + str)

...

>>> class Derived(Base):

... def sayHello(self, str="Derived"):

... print("Dervied says: " + str)

...

>>>

>>> d = Derived()

>>> d.sayHello()

Dervied says: Derived

>>> Base.sayHello(d)

Base says: Base

>>> super(Derived, d).sayHello()

Base says: Base

  

看一下,在基类构造函数中调用被覆盖方法的行为

>>> class Base:

... def sayHello(self):

... str = self.getStr()

... print("Base says: " + str)

... def getStr(self):

... return "Base"

...

>>> class Derived(Base):

... def getStr(self):

... return "Derived"

...

>>>

>>> d = Derived()

>>> d.sayHello()

Base says: Derived

>>> def Base_init(self):

... self.sayHello()

...

>>> Base.__init__ = Base_init

>>> d = Derived()

Base says: Derived

可见,行为类似Java,调用了子类的覆盖方法;

  

Python类中内置的查看直接父类的__bases__属性 属性可以帮助我们在运行时动态地获取类的继承关系。这对于编写通用的代码或进行类的分析和调试非常有用。属性来查看一个类的直接父类。这个属性是一个元组,包含了当前类直接继承的父类。属性,我们可以获取类的继承关系,并了解类与其父类之间的层次结构。这个属性返回一个元组,其中包含了直接父类的引用。Python类中内置的查看直接父类的__bases__属性。最后,我们通过遍历直接父类的元组,并使用。在Python中,我们可以使用。属性,并提供相应的源代码。接下来,我们创建了一个。类的直接父类的类名。从输出结果可以看出, 阅读详情

相关推荐

别再只会用串口助手了!手把手教你用手机App调试HC-05蓝牙模块(STM32F103实战)

本文详细介绍了如何利用手机App调试HC-05蓝牙模块与STM32F103的无线连接,突破传统串口助手的限制。通过实战指南,开发者可以掌握移动性测试、实时监控和快速验证等高效调试技巧,优化蓝牙透传的稳定性和性能。

weixin_33670786的博客 429

python的__bases__属性

即只返回父类,不返回间接父类。

qq_45812220的博客 275

CodeBuddy 接入 MCP,一键生成网站!

2024 年 11 月,Anthropic 公司搞了个挺有意思的新玩意 - Model Context Protocol(模型上下文协议)简称为 MCP 协议。简单来说,它就是给 AI 和各类工具数据之间搭了个标准化的”桥梁”,让开发者不用再为对接问题头疼了。mcp.so如下图所示,这是 mcp.so 网站中的 MCP Server。使用百度/高德地图分析旅线计算时间接 Puppeteer 自动操作网页使用 Github/Gitlab 让大模型接管代码仓库。

悟空聊架构的专栏 1950

Python:python3中__bases__的使用(MRO)

注:尚未在pyhon2中测试 参考文档:https://fishc.com.cn/forum.php?mod=viewthread&tid=48888&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403 · 错误示例 —————————————————————————————————— class A(): def __ini...

Xingzi_c的博客 3074

Altair HyperWorks 2022.3.0 Suite下载

Altair HyperWorks开发团队提供了新的一流技术,以设计和优化高性能、高效和创新的产品,并发布了HyperWorks 2021.2套件。与所有新版本一样,这个版本包含了新特性、增强功能,并修复了前一个版本中用户报告的各种问题,提供了总体上更稳定的体验。链接: https://pan.baidu.com/s/1rYietmQLQUboHiJzYoE9WQ?pwd=m9yh 提取码: m9yh 复制这段内容后打开百度网盘手机App,操作更方便哦。

weixin_48469365的博客 2136

从零搭建YOLOv2硬件加速器:基于PYNQ-Z2的Vivado HLS与Jupyter Notebook实战

本文详细介绍了如何从零搭建YOLOv2硬件加速器,基于PYNQ-Z2开发板,结合Vivado HLS与Jupyter Notebook实现高效目标检测。通过硬件加速,YOLOv2推理速度提升8倍,功耗降低80%。文章涵盖硬件准备、Vivado HLS工程配置、IP核集成、PYNQ部署及常见问题解决,为开发者提供完整实战指南。

weixin_29188997的博客 1011

Python类的定义、方法和属性使用

类用来描述具有相同的属性和方法的对象的集合。 对于在类中定义的函数,称为方法。 类变量不直接叫做类变量,称为属性。 1、类的定义 例子: class User(): pass 说明: (1)定义了一个类名为User的类 (2)类名一般约定用大写字母开头,函数则用小写字母开头,以做区分 (3)用pass表示为空类,暂时还没准备好类的内容 2、类的方法 例子: class U...

gdjlc的专栏 2627

BLDC&PMSM电机控制器硬件设计工程(八)72V 10kW电机控制器原理图工程及库文件

电机控制器基本需求:接口类型;MCU平台;通信接口;供电;信号采集;信号输出;功率;EMC或者认证需求。

小幽余生不加糖 379

第8.9节 Python类中内置的查看直接父类的__bases__属性

终于介绍完了__init__方法和__new__方法,接下来轻松一下,本节介绍类中内置的__bases__属性。 一、 语法释义 Python 为所有类都提供了一个 bases 属性,通过该属性可以查看该类的所有直接父类,该属性返回所有直接父类组成的元组。注意是直接...

weixin_30416497的博客 570

Allegro如何导入芯片的Pin Delay?

Allegro在做等长时,需要导入芯片的Pin Delay才能做真正的等长。因为有些芯片内部的引脚本身就是不等长的,例如海思的部分芯片。在右栏找到芯片U1,然后在Pin Delay栏下找一个PIN脚随便输入一个数值,这一步的目的是导出Pin Delay.csv文件的格式。4、用这份文件的格式,重新编辑需要导入芯片的Pin Delay,然后选择菜单File→Import→Pin delay。2、回到PCB,选择菜单File→Export→Pin delay,导出Pin Delay。

bhxc809751502的博客 5148

环境配置与基础教程:多机多卡分布式训练实战:基于 SLURM 集群调度 YOLOv11,大幅缩短训练周期

摘要: 本文详细介绍了YOLOv11分布式训练在SLURM集群中的完整实现方案。针对单卡训练效率低、环境配置复杂等问题,提出基于多机多卡的分布式优化路径,涵盖硬件选型、RDMA网络配置、PyTorch环境搭建及容器化部署方案。重点解析了YOLOv11的架构演进与核心模块(如C3k2动态卷积),并对比了与YOLOv8的性能差异。通过SLURM调度系统与NFS共享存储,实现训练任务的高效资源分配和数据同步。文中所有配置均基于Ultralytics最新版本验证,为大规模目标检测任务提供了一套可复现的工程实践框架。

ZXSXJ的博客 58

python 类继承 baseclass_Python 类继承,__bases__, __mro__, super

Python是面向对象的编程语言,也支持类继承。>>> class Base:... pass...>>> class Derived(Base):... pass这样就定义了两个类,Derived继承了Base。issubclass(a,b)能够測试继承关系:>>> issubclass(Derived, Base)True在Python中,...

weixin_39796652的博客 677

详细指南:如何在TI C2000基于C28x的微控制器上部署FreeRTOS_C语言实现

FreeRTOS是一个小型、开源、实时的嵌入式操作系统内核。它为多种微控制器和处理器提供了支持,包括ARM、AVR、MSP430和PIC等。小型和轻量级:适合资源受限的嵌入式系统。实时性:可以满足严格的实时要求。多任务支持:支持多任务并发执行。内存管理:提供了多种内存管理策略。模块化设计:用户可以根据需要选择所需的功能模块。TI C2000系列微控制器是专为实时控制应用设计的。高性能C28x核:提供了高速的浮点运算能力。丰富的外设:包括PWM、ADC、DAC、通信接口等。低功耗。

qq_38334677的博客 1607

Python 3.12 类继承实战:super() 解决多继承 MRO 的 3 个典型场景

本文深入探讨Python 3.12中类继承的实战应用,重点解析super()在多继承MRO中的三个典型场景。通过菱形继承、Mixin协作和动态MRO调整的实例,帮助开发者掌握面向对象编程的核心技巧,解决父类方法覆盖和属性初始化等常见问题。

weixin_30457465的博客 462

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Python 中的继承机制:从基础到高级用法详解

继承是一种创建新类的方式,新类(称为子类或派生类)从现有类(称为父类、基类或超类)那里获得其属性和方法。复用父类的代码,避免重复。扩展父类的功能,添加新的属性和方法。修改(重写)父类的方法,以提供特定实现。Python 的继承机制强大而灵活,但需要谨慎使用以避免设计过度复杂。优先使用组合而非继承:如果“有一个”的关系比“是一个”的关系更合适,考虑使用组合(将其他类的实例作为属性)。理解 MRO:在使用多重继承时,务必清楚方法解析顺序。善用super():在重写方法时,使用super()

KevinChen2019的博客 165

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

How does Python's super() work with multiple inheritance?

Python的super()在多继承下的方法推导顺序(MRO, Method Resolution Order)涉及到C3线性化算法(C3 linearization wiki)。其中关键是, children precede their parents and the order of appearance in __bases__ is respected. 例子, ...

weixin_30823833的博客 72

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

如何在子类中访问父类的类变量?

表格访问方式适用场景优缺点父类名。变量名绝大多数业务场景(首选)稳定、不受子类重名干扰super()重写方法时配套使用,兼顾多继承语义贴合继承,但修改类变量不推荐self. 变量 / 子类。变量子类完全不重写父类字段的简单继承简洁,但极易被重名覆盖bases动态编码、不确定父类名称的场景通用性强,日常开发少用。

lay_liu的博客 179

Python 多继承深度解析:MRO、C3 线性化与 super() 的正确打开方式

Python多继承机制通过MRO(方法解析顺序)和C3线性化算法确保方法调用的确定性。C3算法基于三个原则:子类优先、父类按声明顺序排列、保持单调性。super()并非简单调用父类方法,而是按MRO顺序调用下一个类的方法,这使其在多继承中行为可能不同于预期。正确使用多继承需要所有类都遵循协作式调用链,确保super()调用链完整。理解这些机制可以避免常见的初始化遗漏问题,构建可靠的多继承体系。

铭渊老黄 821

深入了解 Python 中的 MRO(方法解析顺序)

在 Python 中,MRO(方法解析顺序)是多重继承的核心机制。它决定了当一个类继承多个父类时,Python 如何解析并决定调用父类的方法。通过 MRO,Python 确保了在多重继承情况下方法不会发生冲突,且每个父类的方法都能按照预定的顺序正确调用。Python 使用一种称为C3 线性化的算法来计算 MRO,这一算法确保了在多继承中父类方法调用的顺序是明确且无歧义的。对于开发者而言,理解 MRO 有助于写出更清晰、易于维护的面向对象代码。

XMYX-0 1982

继承,经典类与新式类的MRO,C3算法,super

#继承 class JiaoFu: def qd(self): print("教父带你祈祷") class Fu: def msj(self): print("alex喜欢msj") class Zi(Fu, JiaoFu): def dbj(self): print("刘伟喜欢...

dmya6801的博客 205

Python的object、type和class以及MRO与super

文章目录object、type和classMRO与super举例 object、type和class object 是 Python 的基础对象类,所有对象都是基础对象的儿子 type 是指类型对象类,type(wh) 可以查看 wh 对象的类型,type(name, bases, dict) 可以动态创建类对象 class 是指类,class wh(hm) 可以静态定义一个继承 hm 对象的类对象 wh #mermaid-svg-MRN0nNrOwlICc8H6 {font-family:"trebuch

昊大侠的博客 958
上一篇: Javascript setTimeout(0),闭包
下一篇: Python,异常 exception
iCode0410
博客等级 码龄14年 6粉丝 50原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值