多继承,封装,多态,super()方法,类的约束

Posted 2021-02-06 antigeneral

多继承:

多继承就是一个类里有多个父类,父类也可以有多个爷爷类.从多个父类中继承属性跟方法.

类的分类:

python2.2之前,只有经典类,pythont2.2之后出现了新式类

经典类:不继承object类,多继承遵循深度优先,从左至右,一条路走到底

class A:
pass

新式类:继承object类,多继承遵循c3算法,mro方法.

class A(object):
pass

python3x版本只有新式类.

鸭子类型:两个结构类似,有弱关联关系的函数或者类.

 

mro方法:(面试会考)

计算要点:表头不在所有元素的表位中,提取出整个列表的所有表头,即使表头在其他元素中也要提取出来

表头在所有元素的末尾,跳过此元素进行下一个元素的表头表位筛选.

 

 

merge([A,(B,C)]) = [A] + merge(mro(B),mro(C),[B,C])

mro(B) =mro(B,(D,E)) = [B] +merge(mro(D),mro[E])

mro(D(O)) = [D,O]

mr(E(O)) = [E,O]

mroB(D,E) = [B] + merge([D,O],[E,O],[D,E])

表头D不在所有元素的表位中,提取出整个列表的所有表头,即使表头在其他元素的表头[D,E]中也要提取出来

　　　　　= [B,D] + merge([O],[E,O],[E])

表头在所有元素的末尾,跳过此元素进行下一个元素的表头表位筛选.

　　　　　= [B,D,E,O]

以下同理详细计算

 

mro(C) = mro(C(E,F)) = [C] + merge(mro(E),mro(F),[E,F])
mro(C) = mro(C(E,F)) = [C] + merge([E,O],[F,O],[E,F])
= [C,E] + merge([O],[F,O],[F])
= [C,E,F] + merge([O],[O])
= [C,E,F,O]

mro(A(B,C)) = [A] + merge([B,D,E,O],[C,E,F,O],[B,C])
= [A,B] + merge([D,E,O],[C,E,F,O],[C])
= [A,B,D] + merge([E,O],[C,E,F,O],[C])
= [A,B,D,C] + merge([E,O],[E,F,O])
= [A,B,D,C,E] + merge([O],[F,O])
= [A,B,D,C,E,F] + merge([O],[O])
= [A,B,D,C,E,F,O]

在实际工作中,可以直接使用.mro()方法去查看继承顺序

class O:
pass

class D(O):
pass

class E(O):
pass

class F(O):
pass

class B(D,E):
pass

class C(E,F):
pass

class A(B,C):
pass

obj = A()
print(A.mro())

 

 

 

封装 函数,模块,类,对象
class A:
def __init__(self,name,age):
self.name = name
self.age =age

obj = A(‘西门‘,18)
print(obj.name)
print(obj.age)

多态
python默认支持多态.
一个事物有用多种形态
水: 固态,液态,气态.
人: 正常,变态.
变形金刚: 汽车人,机器人等.
a = ‘fdasf‘
a = 100
a = [1,2,3]

def func(a):
print(a)

java
int a = 100
int a = ‘alex‘

def func(str a):
print(a)

class F1:
pass


class S1(F1):

def show(self):
print(‘S1.show‘)


class S2(F1):

def show(self):
print(‘S2.show‘)


# # 由于在Java或C#中定义函数参数时，必须指定参数的类型
# # 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# # 而实际传入的参数是：S1对象和S2对象

def Func(F1 obj):
"""Func函数需要接收一个F1类型或者F1子类的类型"""
obj.show()

鸭子类型: 看着像鸭子,就是鸭子.
python 处处都是鸭子类型.

class A:
def add(self):
print(‘增加‘)

def delete(self):
print(‘删除‘)


class B:
def add(self):
print(‘这也是增加‘)

def delete(self):
print(‘这也是删除‘)

def update(self):
pass
obj1 = A()
obj1.add()
obj2 = B()
obj2.add()

 两个类虽然没有任何关系,但是隐形中遵循了一个标准.
1, 统一标准,减少词汇量,
2, A和B没有任何耦合性,但是可以产生关系A的对象会使用B类的方法.

str :index
list index
tuple : index

dict: pop clear
list: pop clear

Super()方法:

super 可以执行非本方法的方法

class A:
def func1(self):
print(‘in A func1‘)

def func2(self):
print(‘in A func2‘)

class B(A):
def func1(self):
print(‘in B func1‘)
super().func2()

obj = B()
obj.func1()

super() 是完全按照mro的顺序执行的.

class A:
def func1(self):
print(‘in A func1‘)

class B(A):
def func1(self):
print(‘in B func1‘)

class C(A):
def func1(self):
print(‘in C func1‘)

class D(B,C):
def func1(self):
super().func1()
print(‘in D func1‘)

obj = D()
obj.func1()

super 是完全按照对象所在类的mro的顺序执行的.
class A:
def func1(self):
print(‘in A func1‘)

class B(A):
def func1(self):
super(B,self).func1()
print(‘in B func1‘)

class C(A):
def func1(self):
print(‘in C func1‘)

class D(B,C):
def func1(self):
super(D,self).func1()

super(X,self).
# 跳过X类,按照mro顺序执行下一个类
print(‘in D func1‘)

obj = D()
obj.func1()
A B D 错误
C B D 正确
print(D.mro()) # D,B,C,A

# class A:
# def func1(self):
# print(‘in A func1‘)

# class B(A):
# def func1(self):
# super(B,self).func1()
# print(‘in B func1‘)

# class C(A):
# def func1(self):
# print(‘in C func1‘)

# class D(B,C):
# def func1(self):
# super(B,self).func1()
# print(‘in D func1‘)

obj = D()
obj.func1()
D B C A

class A:
def func1(self):
print(‘in A func1‘)

class B(A):
def func1(self):
print(‘in B func1‘)

class C:
def func1(self):
print(‘in C func1‘)

class D(B,C):
def func1(self):
super(B,self).func1()
print(‘in D func1‘)

obj = D()
obj.func1()
print(D.mro()) # D B A C

类的约束:(还没弄明白)