算法实现
#-*- encoding:GBK -*-#
def mro_C3(*cls):
if len(cls)==1:
if not cls[0].__bases__:
return cls
else:
return cls+ mro_C3(*cls[0].__bases__)
else:
seqs = [list(mro_C3(C)) for C in cls ] +[list(cls)]
res = []
while True:
non_empty = list(filter(None, seqs))
if not non_empty:
return tuple(res)
for seq in non_empty:
candidate = seq[0]
not_head = [s for s in non_empty if candidate in s[1:]]
if not_head:
candidate = None
else:
break
if not candidate:
raise TypeError("inconsistent hierarchy, no C3 MRO is possible")
res.append(candidate)
for seq in non_empty:
if seq[0] == candidate:
del seq[0]
测试一
#####################测试1
ob=object
class A(ob):
pass
class B(ob):
pass
class X(A,B):
pass
class Y(A,B):
pass
try:
class Z(X,Y):
pass
print Z.mro()
print Z.__mro__
print mro_C3(Z)
except :pass
try:
print mro_C3(X,Y)#如果从X,Y继承,它的MRO值是什么
except Exception,e:
print e
######打印结果
[<class '__main__.Z'>, <class '__main__.X'>, <class '__main__.Y'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>]
(<class '__main__.Z'>, <class '__main__.X'>, <class '__main__.Y'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>)
(<class '__main__.Z'>, <class '__main__.X'>, <class '__main__.Y'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>)
(<class '__main__.X'>, <class '__main__.Y'>, <class '__main__.A'>, <class '__main__.B'>, <type 'object'>)
测试二
#####################测试2
ob=object
class A(ob):
pass
class B(ob):
pass
class X(A):
pass
class Y(B):
pass
try:
class Z(X,Y):
pass
print Z.mro()
print Z.__mro__
print mro_C3(Z)
except :pass
try:
print mro_C3(X,Y)#如果从A,B继承,它的MRO值是什么
except Exception,e:
print e
####打印结果
[<class '__main__.Z'>, <class '__main__.X'>, <class '__main__.A'>, <class '__main__.Y'>, <class '__main__.B'>, <type 'object'>]
(<class '__main__.Z'>, <class '__main__.X'>, <class '__main__.A'>, <class '__main__.Y'>, <class '__main__.B'>, <type 'object'>)
(<class '__main__.Z'>, <class '__main__.X'>, <class '__main__.A'>, <class '__main__.Y'>, <class '__main__.B'>, <type 'object'>)
(<class '__main__.X'>, <class '__main__.A'>, <class '__main__.Y'>, <class '__main__.B'>, <type 'object'>)
测试三
#####################测试3
ob=object
class A(ob):
pass
class B(ob):
pass
class X(A,B):
pass
class Y(B,A):
pass
try:
class Z(X,Y):
pass
print Z.mro()
print Z.__mro__
print mro_C3(Z)
except :pass
try:
print mro_C3(X,Y)#如果从A,B继承,它的MRO值是什么
except Exception,e:
print e
##打印结果 报错了,无法 定义 类 Z
inconsistent hierarchy, no C3 MRO is possible
分享到:
相关推荐
在提供的`Calculate the MRO of a class « Python recipes « ActiveState Code.htm`和`recipe-577748-1.py`文件中,可能包含了C3算法的具体实现和一些测试用例。你可以通过阅读这些代码来更深入地理解C3算法的工作...
C3算法最早被提出是用于Lisp的,应用在Python中是为了解决原来基于深度优先搜索算法不满足本地优先级,和单调性的问题。 本地优先级:指声明时父类的顺序,比如C(A,B),如果访问C类对象属性时,应该根据声明顺序,...
下面就讲解C3算法具体是怎么计算的。 MRO计算规则 首先来定义一些符号: 用CN表示一个类:C1, C2, C3, ..., CN C1 C2 C3 ... CN 表示的是一个包含多个类的列表 其中: head = C1 tail = C2 ... CN 加法运算: C ...
3. **C3线性化**:Python使用C3线性化算法来生成MRO,确保MRO总是确定且一致的。 了解MRO的重要性在于,它可以帮助我们预测和控制代码的执行流程,避免因多继承导致的不确定性和冲突。例如,我们可以使用`__mro__`...
Python使用C3线性化算法来计算这个顺序,基本原则是:先将子类放到列表最前面,然后按照每个基类的MRO和子类的其他基类进行合并,保证不会出现循环引用。可以使用`dir()`函数查看类的`__mro__`属性,以了解其方法...
多继承则可能导致复杂性增加,但通过C3线性化算法,Python保证了MRO的确定性和一致性,使得多继承的代码更加可控。 继承是面向对象编程的重要特性,它允许创建新的类(子类)并复用已存在的类(父类)的代码。通过...
总的来说,Python的多继承MRO通过C3算法保证了在多继承时方法调用的可预测性和一致性。这种设计使得开发者可以更安心地利用多继承来构建复杂的类层次结构,同时避免了可能出现的混乱和意外行为。理解MRO对于编写复杂...
- **C3算法**:在确定MRO时,算法会找到最长的深度优先路径,然后根据基类的相对顺序排列其他路径。这个过程类似于合并排序,以保持基类间的相对顺序不变。 举例来说,如果有以下继承结构: ```python class A: ...
Python使用C3线性化算法来处理继承顺序问题,以确保每个类的方法都能被正确调用。 super()函数在Python中用于调用父类的方法。它是一个特殊的函数,允许子类调用超类(父类)中定义的方法。在多重继承的情况下,...
默认情况下,Python 使用 C3 算法来确定 MRO,它保证了调用顺序的线性一致性。 总的来说,类的继承是 Python 面向对象编程中一个重要的特性,它使得代码的组织更加模块化,提高了代码的可读性和可维护性。通过继承...
关键字函数和mro(Method Resolution Order)继承算法在多态和面向对象编程中扮演关键角色,它们决定了类的方法解析顺序。 魔法函数是Python中以双下划线开头和结尾的特殊方法,如`__init__`(初始化)、`__str__`...
在Python2.3之前,MRO是基于深度优先算法的,自2.3开始使用C3算法,定义类时需要继承object,这样的类称为新式类,否则为旧式类 从图中可以看出,旧式类查找属性时是深度优先搜索,新式类则是广度优先搜索 C3算法最...
为了解决这个问题,Python使用了C3线性化算法来确定一个类的方法查找顺序,即MRO。MRO保证了方法的调用具有确定性和一致性。我们可以通过`__mro__`属性查看类的方法解析顺序,也可以使用`super()`函数按照MRO顺序...
这个顺序被称为方法解析顺序(Method Resolution Order,简称MRO),Python通过C3算法实现这一过程。C3算法是一种基于广度优先搜索的算法,它能够为复杂的多继承结构提供一个线性化的继承顺序。我们可以使用类的.mro...
Python使用C3线性化算法来确定多继承类中方法的调用顺序。我们可以使用`__mro__`属性来查看这个顺序。例如: ```python class A: def method(self): print("A's method") class B: def method(self): print("B...
**MRO(Method Resolution Order)** 是Python中用于确定方法调用顺序的一种算法。它是通过C3线性化算法计算出来的,确保了即使在复杂的继承关系中也能正确地找到方法。 **示例代码:** ```python class X: pass ...
MRO是一个类的方法调用顺序,它遵循C3线性化算法,确保了在多继承的情况下,方法调用的顺序是确定且一致的。简单来说,MRO遵循以下规则: 1. 子类总是出现在父类之前。 2. 同级的父类按照它们在继承列表中的顺序排列...
MRO是由C3线性化算法确定的,通常是从左到右,深度优先的原则。可以使用`__bases__`属性查看一个类的所有父类: ```python print(DerivedClass.__bases__) # 输出所有父类 ``` 3. 重写(Overriding) 方法重写是...
默认情况下,Python使用C3线性化算法来决定调用顺序。 ### 三、教学实践 在教学过程中,可以通过实例来让学生更好地理解和掌握继承的概念。例如,可以设计如下两个范例: 1. **范例7-8**(单继承的使用):展示...