导读:很多朋友问到关于python类的继承有多少方法的相关问题,本文首席CTO笔记就来为大家做个详细解答,供大家参考,希望对大家有所帮助!一起来看看吧!
Python类的多重继承问题深入分析
Python类的多重继承问题深入分析
首先得说明的是,Python的类分为经典类 和 新式类
经典类是python2.2之前的东西,但是在2.7还在兼容,但是在3之后的版本就只承认新式类了
新式类在python2.2之后的版本中都可以使用
经典类和新式类的区别在于:
经典类是默认没有派生自某个基类的,而新式类是默认派生自object这个基类的:
代码如下:
# old style
class A():pass
# new style
class A(obejct):pass
2.经典类在类多重继承的时候是采用从左到右深度优先原则匹配方法的..而新式类是采用C3算法(不同于广度优先)进行匹配的
3.经典类是没有__MRO__和instance.mro()调用的,而新式类是有的.
为什么不用经典类,要更换到新式类
因为在经典类中的多重继承会有些问题...可能导致在继承树中的方法查询绕过后面的父类:
代码如下:
class A():
def foo1(self):
print \"A\"
class B(A):
def foo2(self):
pass
class C(A):
def foo1(self):
print \"C\"
class D(B, C):
pass
d = D()
d.foo1()
按照经典类的查找顺序从左到右深度优先的规则,在访问d.foo1()的时候,D这个类是没有的..那么往上查找,先找到B,里面没有,深度优先,访问A,找到了foo1(),所以这时候调用的是A的foo1(),从而导致C重写的foo1()被绕过.
所以python引入了新式类的概念,每个基类都继承自object并且,他的匹配规则也从深度优先换到了C3
C3算法
C3算法是怎么做匹配的呢..在问答版块上面讨论之后,归结如下:
C3算法的一个核心是merge.
在merge列表中,如果第一个序列mro的第一个类是出现在其它序列,并且也是第一个,或者不出现其它序列,那么这个类就会从这些序列中删除,并合到访问顺序列表中
比如:(引用问题中zhuangzebo的回答@zhuangzebo)
代码如下:
class A(O):pass
class B(O):pass
class C(O):pass
class D(A,B):pass
class E(C,D):pass
首先需要知道 O(object)的mro(method resolution order)列表是[O,]
那么接下来是:
代码如下:
mro(A) = [A, O]
mro(B) = [B, O]
mro(C) = [C, O]
mro(D) = [D] + merge(mro(A), mro(B), [A, B])
= [D] + merge([A, O], [B, O], [A, B])
= [D, A] + merge([O], [B, O], [B])
= [D, A, B] + merge([O], [O])
= [D, A, B, O]
mro(E) = [E] + merge(mro(C), mro(D), [C, D])
= [E] + merge([C, O], [D, A, B, O], [C, D])
= [E, C] + merge([O], [D, A, B, O], [D])
= [E, C, D] + merge([O], [A, B, O])
= [E, C, D, A, B] + merge([O], [O])
= [E, C, D, A, B, O]
然后还有一种特殊情况:
比如:
merge(DO,CO,C) 先merge的是D
merge(DO,CO,C) 先merge的是C
意思就是.当出现有 一个类出现在两个序列的头(比如C) 这种情况和 这个类只有在一个序列的头(比如D) 这种情况同时出现的时候,按照顺序方式匹配。
新式类生成的访问序列被存储在一个叫MRO的只读列表中..
你可以使用instance.__MRO__或者instance.mro()来访问
最后匹配的时候就按照MRO序列的顺序去匹配了
C3和广度优先的区别:
举个例子就完全明白了:
代码如下:
class A(object):pass
class B(A):pass
class C(B):pass
class D(A):pass
class E(D):pass
class F(C, E):pass
按照广度优先遍历,F的MRO序列应该是[F,C,E,B,D,A]
但是C3是[F,E,D,C,B,A]
意思是你可以当做C3是在一条链路上深度遍历到和另外一条链路的交叉点,然后去深度遍历另外一条链路,最后遍历交叉点
新式类和经典类的super和按类名访问问题
在经典类中,你如果要访问父类的话,是用类名来访问的..
代码如下:
class A():
def __init__(self):
print \"A\"
class B(A):
def __init__(self):
print \"B\"
A.__init__(self) #python不会默认调用父类的初始化函数的
这样子看起来没三问题,但是如果类的继承结构比较复杂,会导致代码的可维护性很差..
所以新式类推出了super这个东西...
代码如下:
class A():
def __init__(self):
print \"A\"
class B(A):
def __init__(self):
print \"B\"
super(B,self).__init__()
这时候,又有一个问题:当类是多重继承的时候,super访问的是哪一个类呢?
super实际上是通过__MRO__序列来确定访问哪一个类的...实际上就是调用__MRO__中此类后面的一个类的方法.
比如序列为[F,E,D,C,B,A]那么F中的super就是E,E的就是D
super和按照类名访问 混合使用带来的坑
代码如下:
class A(object):
def __init__(self):
print \"enter A\"
print \"leave A\"
class B(object):
def __init__(self):
print \"enter B\"
print \"leave B\"
class C(A):
def __init__(self):
print \"enter C\"
super(C, self).__init__()
print \"leave C\"
class D(A):
def __init__(self):
print \"enter D\"
super(D, self).__init__()
print \"leave D\"
class E(B, C):
def __init__(self):
print \"enter E\"
B.__init__(self)
C.__init__(self)
print \"leave E\"
class F(E, D):
def __init__(self):
print \"enter F\"
E.__init__(self)
D.__init__(self)
print \"leave F\"
这时候打印出来是:
代码如下:
enter F
enter E
enter B
leave B
enter C
enter D
enter A
leave A
leave D
leave C
leave E
enter D
enter A
leave A
leave D
leave F
可以看出来D和A的初始化函数被乱入了两次!
按类名访问就相当于C语言之前的GOTO语句...乱跳,然后再用super按顺序访问..就有问题了
所以建议就是要么一直用super,要么一直用按照类名访问
最佳实现:
避免多重继承
super使用一致
不要混用经典类和新式类
调用父类的时候注意检查类层次
以上便是本人对于python类的继承的认识了,希望对大家能有所帮助
Python类的继承和多态代码详解
Python类的继承和多态代码详解
Python类的继承
在OOP(ObjectOrientedProgramming)程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、Superclass)。
我们先来定义一个classPerson,表示人,定义属性变量name及sex(姓名和性别);
定义一个方法print_title():当sex是male时,printman;当sex是female时,printwoman。参考如下代码:
class Person(object):
def __init__(self,name,sex):
self.name = name
self.sex = sex
def print_title(self):
if self.sex == \"male\":
print(\"man\")
elif self.sex == \"female\":
print(\"woman\")
class Child(Person): # Child 继承 Person
pass
May = Child(\"May\",\"female\")
Peter = Person(\"Peter\",\"male\")
print(May.name,May.sex,Peter.name,Peter.sex) # 子类继承父类方法及属性
May.print_title()
Peter.print_title()
而我们编写Child类,完全可以继承Person类(Child就是Person);使用classsubclass_name(baseclass_name)来表示继承;
继承有什么好处?最大的好处是子类获得了父类的全部属性及功能。如下Child类就可以直接使用父类的print_title()方法
实例化Child的时候,子类继承了父类的构造函数,就需要提供父类Person要求的两个属性变量name及sex:
在继承关系中,如果一个实例的数据类型是某个子类,那它也可以被看做是父类(May既是Child又是Person)。但是,反过来就不行(Peter仅是Person,而不是Child)。
继承还可以一级一级地继承下来,就好比从爷爷到爸爸、再到儿子这样的关系。而任何类,最终都可以追溯到根类object,这些继承关系看上去就像一颗倒着的树。比如如下的继承树:
isinstance()及issubclass()
Python与其他语言不同点在于,当我们定义一个class的时候,我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型,比如str、list、dict没什么两样。
Python有两个判断继承的函数:isinstance()用于检查实例类型;issubclass()用于检查类继承。参见下方示例:
class Person(object):
pass
class Child(Person): # Child 继承 Person
pass
May = Child()
Peter = Person()
print(isinstance(May,Child)) # True
print(isinstance(May,Person)) # True
print(isinstance(Peter,Child)) # False
print(isinstance(Peter,Person)) # True
print(issubclass(Child,Person)) # True
Python类的多态
在说明多态是什么之前,我们在Child类中重写print_title()方法:若为male,printboy;若为female,printgirl
class Person(object):
def __init__(self,name,sex):
self.name = name
self.sex = sex
def print_title(self):
if self.sex == \"male\":
print(\"man\")
elif self.sex == \"female\":
print(\"woman\")
class Child(Person): # Child 继承 Person
def print_title(self):
if self.sex == \"male\":
print(\"boy\")
elif self.sex == \"female\":
print(\"girl\")
May = Child(\"May\",\"female\")
Peter = Person(\"Peter\",\"male\")
print(May.name,May.sex,Peter.name,Peter.sex)
May.print_title()
Peter.print_title()
当子类和父类都存在相同的print_title()方法时,子类的print_title()覆盖了父类的print_title(),在代码运行时,会调用子类的print_title()
这样,我们就获得了继承的另一个好处:多态。
多态的好处就是,当我们需要传入更多的子类,例如新增Teenagers、Grownups等时,我们只需要继承Person类型就可以了,而print_title()方法既可以直不重写(即使用Person的),也可以重写一个特有的。这就是多态的意思。调用方只管调用,不管细节,而当我们新增一种Person的子类时,只要确保新方法编写正确,而不用管原来的代码。这就是著名的“开闭”原则:
对扩展开放(Openforextension):允许子类重写方法函数
对修改封闭(Closedformodification):不重写,直接继承父类方法函数
子类重写构造函数
子类可以没有构造函数,表示同父类构造一致;子类也可重写构造函数;现在,我们需要在子类Child中新增两个属性变量:mother和father,我们可以构造如下(建议子类调用父类的构造方法,参见后续代码):
class Person(object):
def __init__(self,name,sex):
self.name = name
self.sex = sex
class Child(Person): # Child 继承 Person
def __init__(self,name,sex,mother,father):
self.name = name
self.sex = sex
self.mother = mother
self.father = father
May = Child(\"May\",\"female\",\"April\",\"June\")
print(May.name,May.sex,May.mother,May.father)
Person
若父类构造函数包含很多属性,子类仅需新增1、2个,会有不少冗余的代码,这边,子类可对父类的构造方法进行调用,参考如下:
class Person(object):
def __init__(self,name,sex):
self.name = name
self.sex = sex
class Child(Person): # Child 继承 Person
def __init__(self,name,sex,mother,father):
Person.__init__(self,name,sex) # 子类对父类的构造方法的调用
self.mother = mother
self.father = father
May = Child(\"May\",\"female\",\"April\",\"June\")
print(May.name,May.sex,May.mother,May.father)
多重继承
多重继承的概念应该比较好理解,比如现在需要新建一个类baby继承Child,可继承父类及父类上层类的属性及方法,优先使用层类近的方法,代码参考如下:
class Person(object):
def __init__(self,name,sex):
self.name = name
self.sex = sex
def print_title(self):
if self.sex == \"male\":
print(\"man\")
elif self.sex == \"female\":
print(\"woman\")
class Child(Person):
pass
class Baby(Child):
pass
May = Baby(\"May\",\"female\") # 继承上上层父类的属性
print(May.name,May.sex)
May.print_title() # 可使用上上层父类的方法
class Child(Person):
def print_title(self):
if self.sex == \"male\":
print(\"boy\")
elif self.sex == \"female\":
print(\"girl\")
class Baby(Child):
pass
May = Baby(\"May\",\"female\")
May.print_title() # 优先使用上层类的方法
总结
以上就是本文关于Python类的继承和多态代码详解的全部内容,希望对大家有所帮助。
又来求助了,大神求解答 python类继承的问题
一、类定义:
class 类名:
语句
类实例化后,可以使用其属性,实际上,创建一个类之后,可以通过类名访问其属性
如果直接使用类名修改其属性,那么将直接影响到已经实例化的对象
类的私有属性:
__private_attrs 两个下划线开头,声明该属性为私有,不能在类地外部被使用或直接访问
在类内部的方法中使用时 self.__private_attrs
类的方法
在类地内部,使用def关键字可以为类定义一个方法,与一般函数定义不同,类方法必须包含参数self,且为第一个参数
私有的类方法
__private_method 两个下划线开头,声明该方法为私有方法,不能在类地外部调用
在类的内部调用slef.__private_methods
类的专有方法:
__init__ 构造函数,在生成对象时调用
__del__ 析构函数,释放对象时使用
__repr__ 打印,转换
__setitem__按照索引赋值
__getitem__按照索引获取值
__len__获得长度
__cmp__比较运算
__call__函数调用
__add__加运算
__sub__减运算
__mul__乘运算
__div__除运算
__mod__求余运算
__pow__称方
示例:
#类定义
class people:
#定义基本属性
name = \'\'
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print(\"%s is speaking: I am %d years old\" %(self.name,self.age))
p = people(\'tom\',10,30)
p.speak()
二、继承类定义:
1.单继承
class 类名(父类名)
语句
eg.
class childbook(book)
age = 10
2.类的多重继承
class 类名(父类1,父类2,....,父类n)
语句1
需要注意圆括号中父类的顺序,若是父类中有相同的方法名,而在子类使用时未指定,python从左至右搜索,即方法在子类中未找到时,从左到右查找父类中是否包含方法
#另一个类,多重继承之前的准备
class speaker():
topic = \'\'
name = \'\'
def __init__(self,n,t):
self.name = n
self.topic = t
def speak(self):
print(\"I am %s,I am a speaker!My topic is %s\"%(self.name,self.topic))
#多重继承
class sample(speaker,student):
a =\'\'
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g)
speaker.__init__(self,n,t)
test = sample(\"Tim\",25,80,4,\"Python\")
test.speak()#方法名同,默认调用的是在括号中排前地父类的方法
类方法的覆写——子类覆盖掉父类的方法
def 方法名与父类一致
若是在方法中要使用到父类方法 父类名.方法名
若是将类放到了模块中
使用时
import A
l = A.类()
Python类的继承与多态详细介绍
类(Class): 用来描述具有相同的属性和方法的对象的集合。
类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
类有一个名为 __init__() 的特殊方法(构造方法),该方法在类实例化时会自动调用
self:self 代表的是类的实例,代表当前对象的地址,而 self.class 则指向类。
类调用 Car.weight
实例化 car01=Car(5)
实例对象调用 car01.weght
我们在构造类时,Python3默认我们继承了object这个基类,我个人理解object就是个空的类,可以不用管为何要在括号中写上object,这是Python3的特性,在python2中如果你没有写object的话不会默认继承了object这个基类。
同样的我们自己希望继承的父类只需要把objetc改为我们自己定义的类名即可。子类中可以拥有父类中所有的公有属性和方法,但是可以通过在变量名前加下划线使其变为私有,这样子类就不可以访问父类中的成员了。
以下三个公交车类的父类均为客车类,我们可以写一个funcs方法使得每次调用funcs方法时,传入不同的对象以执行不同的func方法,具体实现如下:
主函数 :
可以看到,我将小 汽车 实例化为带有重量为5t的一个具体对象,将客车实例化为带有重量为20t的一个具体对象,将三个公交车实例化为带有重量为15t的一个具体对象.
如上图所示,我每次在调用funcs方法时都传入了一个实例化对象,funcs根据不同的对象执行相应的内部方法。
python类的继承!!谁能用通俗的方法,给小弟讲一下,类的继承!!
python的继承实际上是一个指针或者是引用的链表。它是动态语言。
面向对象有多态、继承、封装几个主要概念。要形成面向对象还需要分层,抽象,动静态建模等技能。
继承通常是指类的继承,派生类从基类里继承它的属性与方法。当然也可以重载基类的方法,或者是重写方法。python里虽然可以重写方法,不过仍然可以通过super等函数修饰获得基类方法。
基类又称父类。派生类也称为子类。
属性就是对象中的变量。方法就是对象中的函数。
类是一种定义。如果类有了实例,就称为对象。类是对象的静态结构的描述,是声明。
结语:以上就是首席CTO笔记为大家整理的关于python类的继承有多少方法的相关内容解答汇总了,希望对您有所帮助!如果解决了您的问题欢迎分享给更多关注此问题的朋友喔~
以上内容为新媒号(sinv.com.cn)为大家提供!新媒号,坚持更新大家所需的互联网后端知识。希望您喜欢!
版权申明:新媒号所有作品(图文、音视频)均由用户自行上传分享,仅供网友学习交流,不声明或保证其内容的正确性,如发现本站有涉嫌抄袭侵权/违法违规的内容。请发送邮件至 k2#88.com(替换@) 举报,一经查实,本站将立刻删除。