多继承:
多继承就是一个类里有多个父类,父类也可以有多个爷爷类.从多个父类中继承属性跟方法.
类的分类:
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
类的约束:(还没弄明白)
原文地址：https://www.cnblogs.com/antigeneral/p/10324776.html