python继承初始化类

A. __init__ 为什么python类需要初始化

通常构造一个类，用 init 初始化：

为什么python类需要初始化
1.python 类初始化属性 def __init__() 中定义，实例化对象后可直接调用
2.python 类非初始化属性在 def func() 中定义，实例化对象后, 先调用调用函数，再调用属性

结果：

B. 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类的继承的认识了，希望对大家能有所帮助

C. python在类中初始化另一个类

第一个问题：queryservice继承了service,第一个问题处的意思是同样把service里的init method原封不动继承过来。没有保存什么值。
第二个问题：你用init初始化时后面的括号里是self和request，而request你给的默认值是none，也就是说编译完了用的时候，我可以QueryService(request='xxxx') 也可以直接QueryService()。而self.request = request的意思是把用户输入的request，也就是'xxx'保存到内部。

解释的不太清楚，建议阅读一下各种python书面向对象编程这块，lz问的都是最基础的问题

D. python中类的继承以及父类中的变量继承是如何使用的

你必须在Equilateral的__init__方法中显式调用父类Triangle的__init__方法。

E. Python继承父类parent的正确格式为

格式：

class 子类名(父类1，父类2)

类的继承就是让子类拥有父类的属性和方法。

几个注意：py支持多继承

子类继承的父类只能初始化一次，如果父类1和父类2有共同的父类或者祖先类，则类初始化的时候会失败。

当父类具有相同方法时，会调用最先继承的父类中的方法，如果要指定父类，则需要重写此方法，并通过父类名.方法名来调用指定父类方法。

F. Python中的多继承

单继承：一个派生类的基类只有一个
多继承：一个派生类的基类有多个
一句话区分就是：单继承是一个生一个，多继承是多个生一个
多继承的基本语法：

子类定义构造方法时，需要将父类的构造方法调用一次。
案例演示：

在则答掘多继承中，所有基类的方法可以直接继承，但是属性需要手工初始举闭化。如果派生类中没有 __init__ 方法，则默认获得第一个类的属性。如果派生类中有 __init__ 方法，则所有基类的属性都不会获得，需要手动逐孙核一初始化。

我们定义一个ChineseStudent类，其继承关系如下：

调用基类的属性和方法

在不同的基类中存在相同的方法，派生类对象调用方法时会调用哪个父类的方法呢？
默认情况下，如果多个基类中有相同的方法，越在前面，优先级越高。
为了避免后期没必要的错误，建议基类之间存在重名的属性和方法应该尽量避免。

MRO(Method Resolution Order)方法解析顺序

如果是经典类（旧式类），MRO的方法--DFS（深度优先搜索）策略

如果是新式类，MRO的方法--BFS（广度优先搜索）策略

G. python中子类对父类初始化变量的赋值

1、使用self.x = x这样来添加变量
2、对于父类的初始化参数，如果不写，默认就使用父类无参的__init__方法
3、子类初始化父类参数B.__init__(self,aa,ab)
4、使用super(子类类型,子类对象).foo()调用父类方法

H. python 编程， 类初始化问题

1.self.__class__
self是当前，类的实例的变量，self.__class__用于获得对应的类的本身的变量。

2.前面通过
class Circle:
定义而来一个类，叫做Circle
其中，定义了类的变量：
all_circles = []
表示是：一个名叫all_circles的列表，并且初始化赋值为[]，表示一个空的列表。

3.all__这是什么用法？
是你看错了。
实际是：
all_circles
这是一个单个的变量而已；
这个变量，是之前类Circle中的变量all_circles。

关于这部分内容，建议你去看看我所总结的：
【整理】Python中：self和init__的含义 + 为何要有self和__init__
和
【整理】Python中变量的作用域(variable scope)
就懂了。
里面有截图解释的，便于你理解。

(此处不给贴地址，请自己用google搜标题，即可找到帖子地址)

I. python的初始化方法有什么用

1.
在程序执行时一定执行一次的操作

2.
python中初始化init 参数第一个必须要加 self

3.
对变量进行赋值 继承: 子类继承父类

J. Python子类继承，如果不用父类的函数和方法，应该怎么写

子类继承父类时,如果父类有需要初始化的属性,那么必须在子类中调用父类的初始化方法,帮助父类进行初始化,否则,子类可以不调用父类的初始化方法

代码示例

"""
父类Car中没有属性需要初始化,所有子类中也不需要调用父类的初始化方法
"""


classCar:

defshow_name(self):
print('carname')


classEeleCar(Car):
pass


car=EeleCar()
car.show_name()