Python全栈开发——类继承和组合

# 类组合将几个不相关的类组合在一起#什么时候用：当类之间有显著的不同，并且较小的类是较大的类所需组件时，用组合

class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def zhao_sheng(self):
        print(‘%s is ‘ %self.name)
class Course:
    def __init__(self,name,price,period,school):
        self.name=name
        self.price=price
        self.period=period
        self.school_lujiacheng=school
s1=School(‘oldboy‘,‘BeiJing‘)

c1=Course(‘boydoy‘,‘1000‘,15,s1)   #建立关系
#访问
print(c1.school_lujiacheng.name)    #oldboy
print(c1.school_lujiacheng.addr)    #BeiJing

#继承 #当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好 #继承的两种含义 #1.继承基类的方法，并做出自己的扩展（代码重用（强耦合，意义不是很大）少用） #2.声明某个子类兼容于某基类，定义一个接口类，子类继承接口类，并实现接口中定义的方法（归一化继承）

#子类创建数据属性和函数属性，实例化后会先找子类中的属性

class Dad:
    money=10
    def __init__(self,name):
        print(‘爸爸‘)
        self.name=name
    def hit_son(self):
        print(‘%s 正在打儿子‘ %self.name)

class Son(Dad):
    money = 10000000
    def __init__(self,name,age):
        self.name=name
        self.age=age

s1=Son(‘alex‘,‘19‘)
print(s1.name)     #10000000
print(s1.money)   #‘alex‘
s1.hit_son()

#继承顺序 #1.当类是经典类时，多继承情况下，会按照深度优先方式查找 #2.当类是新式类时，多继承情况下，会按照广度优先方式查找 #Python2.x灰分经典类和新式类，Python3.x统一为新式类 #深度优先 #  F->D->B->A->E->C          #从左找起 

#广度优先  #  F->D->B->E->C->A           #从左找起

class A:
    def test(self):
        print(‘A‘)
class B(A):
    def test(self):
        print(‘B‘)
class C(A):
    def test(self):
        print(‘C‘)
class D(B):
    def test(self):
        print(‘D‘)
class E(C):
    def test(self):
        print(‘E‘)
class F(D,E):
    pass
    # def test(self):
    #     print(‘F‘)
f1=F()
f1.test()  #F->D->B->E->C->A 实在找不到才会去找A类

#接口继承，第二中继承方式（更好）（归一化设计） #基类中只定义方法，不写功能。而在继承基类中的类必须定义基类中所有的方法，不然会报错

import abc
class All_file(metaclass=abc.ABCMeta):#限制继承基类中的类必须定义基类中所有的方法

    @abc.abstractmethod
    def read(self):
        pass
    @abc.abstractmethod
    def write(self):
        pass

class Disk(All_file):
    def read(self):
        print(‘Disk is reading‘)
    def write(self):
        print(‘Disk is writing‘)

class Mess(All_file):
    def read(self):
        print(‘Mess is reading‘)
    def write(self):
        pass
m1=Mess()

#子类中调用父类的方法

#1.这种方法扩展性差(一般不用，也不会用)

class Vehicle:
    Country=‘China‘
    def __init__(self,name,speed,load,power):
        self.name=name
        self.speed=speed
        self.load=load
        self.power=power
    def run(self):
        print(‘正在跑......‘)
class Subway(Vehicle):
    def __init__(self,name,speed,load,power,line):

        Vehicle.__init__(self,name,speed,load,power) #这样调用父类方法
        self.line=line
    def run(self):
        Vehicle.run(self)          #调用父类
line1=Subway(‘13号线‘,‘13Km‘,‘100kg‘,‘电‘,‘line‘)
print(line1.__dict__)
#{‘name‘: ‘13号线‘, ‘speed‘: ‘13Km‘, ‘load‘: ‘100kg‘, ‘power‘: ‘电‘, ‘line‘: ‘line‘}
line1.run()

#第二种调用(更好)

#super（）

class Vehicle:
    Country=‘China‘
    def __init__(self,name,speed,load,power):
        self.name=name
        self.speed=speed
        self.load=load
        self.power=power
    def run(self):
        print(‘正在跑......‘)

class Subway(Vehicle):
    def __init__(self,name,speed,load,power,line):

        # 这样调用父类方法
        #super().__init__(name,speed,load,power)#相当于下面的方法
        super(Subway,self).__init__(name,speed,load,power)
        self.line=line

    def run(self):
        super().run()        #这样调用父类方法
line1=Subway(‘13号线‘,‘13Km‘,‘100kg‘,‘电‘,‘line‘)
line1.run()      #正在跑......

原文地址：https://www.cnblogs.com/lujiacheng-Python/p/9733876.html