# 組合：自定義類的對象作為另外一個類的屬性
class Teacher:
def __init__(self,name,age):
self.name = name
self.age= age
t1=Teacher('bob',17)
class Student:
def __init__(self,name,age,teacher):
self.name =name
self.age = age
self.teacher = teacher
stu =Student('xiao ming',18,t1)
print(stu.teacher.name)
print(stu.__dict__)
print(stu.teacher.__dict__)
#繼承：將所有的共有的屬性與方法抽離出，形成父類
#父類是多個有共同點的普通類抽離出屬性與方法形成的類
class People:
def __init__(self ,name):
self.name = name
def eat(self):
print(self.name+'在吃飯')
class Student(People):
identify = '學生'
class Teacher(People):
identify = '老師'
class Leader(People):
identify = '領導'
stu = Student('bob')
print(stu.name)
print(stu.identify)
stu.eat()
tea = Teacher('owen')
print(tea.name)
print(tea.identify)
tea.eat()
lead = Leader('YANG')
print(lead.name)
print(lead.identify)
lead.eat()
#繼承語法：
#class 類名（父類名）：pass
class A:
pass
print(A.__bases__)#(<class 'object'>,)
print(Student.__bases__)#(<class '__main__.People'>,)
print(Student.identify)#父類沒有，其他類就沒有，有的都是自身的
print(Leader.identify)
print(Teacher.identify)

#繼承的信息
class Sup:
__num = 10
def __init__(self,name):
self.__name = name
@property
def name (self):
print(123)
return self.__name
@classmethod
def __c_fn(cls):
print(cls,'c fn')

def __o_fn(self):
print('o fn')
class Sub(Sup):
def test(self):
print(self)
print(self.__name)
print(Sub._Sup__num)
print(Sub('bob').name)
Sub(18)._Sup__c_fn()
Sub(18)._Sup__o_fn()#以上除了接口外都是非正常調用

#繼承關系
#1.父類的所有未封裝的屬性與方法，子類都能訪問
#2.父類的所有封裝的屬性與方法，子類都不能訪問
# --在外界通過子類或子類對象，不能訪問
# --在子類內部也不能訪問


#方法的重寫
#有繼承關系的屬性查找順序如下：
#1.優先找自身，自身沒有找父類
#2.父類沒有找父類的父類
#3.一直找到最頂級的父類，如果還沒有報錯


class Sup:
num = 10
def test(self):
print('test sup')
class Sub(Sup):
num=10
#先寫好父類的方法，由于父類的方法功能不滿足子類需求
#子類可以重寫父類方法：方法名與父類相同，自定義方法的實現體

def test(self):
print('test sub')

print(Sub.num)
Sub().test()

#方法的重用
class Sup:
pass
#重用：還需要父類的功能，在父類方法功能基礎上再添加新功能
#突破點：在子類中去調用父類的方法，還有保證調用者是子類（子類的對象）
def test(self):
print('>>sup',self)
print('test sup')
class Sub(Sup):
def test(self):
super().test()
#python3簡化了，
# super（Sub，self）.test() 在python2中
print('test sub')
print('>>sub',self)
print('test sub')
Sub().test()

#super與__init__
#人類：初始化——name
#老師：初始化——name salary
#學生：初始化——name grade
class Sup:
def test(self):
print(self)

def __init__(self,name):
self.name = name
class Sub(Sup):
#有繼承關系關系下，只要名字相同 ，即使產生不同，還是屬于同一個方法
def test(self,num):
super().test()
print(num)
def __init__(self,name,salary):
super().__init__(name)
self.salary = salary
#Sub().test(10)
Sub('bob',19).test(1)

#簡單的多繼承
#屬性的查找順序：優先找自己的，如果沒有，按照繼承先后查找父級
class A:
name = 'A'
num=10
class B:
name = 'B'
count = 100
class C(A,B):
name = 'C'
print(C.num)
print(C.count)
print(C.name)
print(C.mro())#打印查找順序
#復雜的多繼承
class A:
name ='A'
class B(A):
name = 'B'
class C:
name = 'C'
class D(C):
name = 'D'
class E(B,D):
name = 'E'
print(E.mro())
#菱形是先廣再深度 python3
class G: name = 'G'
class C(G): pass
class B(C):pass
class E(G):pass
class D(E):pass
class F(G):pass
class A(B,D,F):pass
print(A.mro())

轉載于:https://www.cnblogs.com/guanlei/p/10736908.html

《新程序員》：云原生和全面數字化實踐50位技術專家共同創作，文字、視頻、音頻交互閱讀

總結

以上是生活随笔為你收集整理的组合与类继承的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。