day22 组合、菱形继承问题、C3算法与mro介绍、在子类派生的新方法中重用父类功能的两种方式、super()严格以来继承关系、多态与鸭子类型

1、什么是组合？

组合就是一个类的对象具备某一个属性，该属性的值是指向另外一个类的对象

2、为何用组合

组合也是用来解决类与类之间代码冗余的问题

3、如何用组合

组合的例子

class Course:
    def __init__(self,name,period,price):
        self.name=name
        self.period=period
        self.price=price

    def tell_info(self):
        msg="""
        课程名：%s
        课程周期：%s
        课程价钱：%s
        """ %(self.name,self.period,self.price)
        print(msg)

class OldboyPeople:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyStudent(OldboyPeople):
    def __init__(self,name,age,sex,stu_id):
        OldboyPeople.__init__(self,name,age,sex)
        self.stu_id=stu_id

    def choose_course(self):
        print('%s is choosing course' %self.name)

class OldboyTeacher(OldboyPeople):

    def __init__(self, name, age, sex, level):
        OldboyPeople.__init__(self,name,age,sex)
        self.level=level

    def score(self,stu,num):
        stu.score=num
        print('老师[%s]为学生[%s]打分[%s]' %(self.name,stu.name,num))

# 创造课程
python=Course('python全栈开发','5mons',3000)
linux=Course('linux运维','5mons',800)
# python.tell_info()
# linux.tell_info()


# 创造学生与老师
stu1=OldboyStudent('猪哥',19,'male',1)
tea1=OldboyTeacher('egon',18,'male',10)


# 将学生、老师与课程对象关联/组合
stu1.course=python
tea1.course=linux

stu1.course.tell_info()
tea1.course.tell_info()

当类与类之间存在什么是什么的关系的时候用继承

1 、菱形继承

 当一个子继承多个父类时，多个父类最终继承了同一个类，称之为菱形继承

2、菱形继承的问题

python2区分经典类与新式类，如果子的继承是一个菱形继承，那么经典类与新式类的区别

　　经典类下查找属性,深度优先查找

　　新式类下查找属性,广度优先查找

相关习题

class A(object):
    def __init__(self):
        print('A')
        super(A, self).__init__()

class B(object):
    def __init__(self):
        print('B')
        super(B, self).__init__()

class C(A):
    def __init__(self):
        print('C')
        super(C, self).__init__()

class D(A):
    def __init__(self):
        print('D')
        super(D, self).__init__()

class E(B, C):
    def __init__(self):
        print('E')
        super(E, self).__init__()

class F(C, B, D):
    def __init__(self):
        print('F')
        super(F, self).__init__()

class G(D, B):
    def __init__(self):
        print('G')
        super(G, self).__init__()

if __name__ == '__main__':
    # g = G()
    f = F()

　

 

不用一条道走到黑，E找不到，再找C,C没有找F，在最后那条分支找到那个点

 一、没有继承任何类的类以及他的子类都称之为经典类

C3算法与mro介绍

在子派生的新方法中重用父类功能的两种方式

# 在子派生的新方法中重用父类功能的两种方式
# 方式一：与继承无关
# 指名道姓法，直接用：类名.函数名
class OldboyPeople:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyStudent(OldboyPeople):
    def __init__(self,name,age,sex,stu_id):
        OldboyPeople.__init__(self,name,age,sex)
        self.stu_id=stu_id

    def choose_course(self):
        print('%s is choosing course' %self.name)


# 方式二：严格依赖继承属性查找关系
# super()会得到一个特殊(专门访问父类)的对象，该对象就是专门用来访问父类中的属性的（按照继承的关系）
# super().__init__(不用为self传值)
# 注意：
# super的完整用法是super(自己的类名,self),在python2中需要写完整，而python3中可以简写为super()
class OldboyPeople:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyStudent(OldboyPeople):
    def __init__(self,name,age,sex,stu_id):
        # OldboyPeople.__init__(self,name,age,sex)相比之前的换了一种写法
        super(OldboyStudent,self).__init__(name,age,sex)#严格依赖继承
        self.stu_id=stu_id

    def choose_course(self):
        print('%s is choosing course' %self.name)


stu1=OldboyStudent('猪哥',19,'male',1)
print(stu1.__dict__)

print(OldboyStudent.mro())

pthon继承基于C3算法算出来的，

C3算法其实是继承之间的查找关系

在子派生的新方法中重用父类功能的两种方式
方式一：与继承无关
指名道姓法，直接用：类名.函数名

class OldboyPeople:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyStudent(OldboyPeople):
    def __init__(self,name,age,sex,stu_id):
        OldboyPeople.__init__(self,name,age,sex)
        self.stu_id=stu_id

    def choose_course(self):
        print('%s is choosing course' %self.name)

　

方式二:严格依赖继承属性来查找关系

super()会得到一个特殊的对象，该对象就是专门用来访问父类中的属性的（按照继承的关系）
super().__init__(不用为self传值)
注意：
super的完整用法是super(自己的类名,self),在python2中需要写完整，而python3中可以简写为super()
class OldboyPeople:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

class OldboyStudent(OldboyPeople):
    def __init__(self,name,age,sex,stu_id):
        # OldboyPeople.__init__(self,name,age,sex)
        super(OldboyStudent,self).__init__(name,age,sex)
        self.stu_id=stu_id

    def choose_course(self):
        print('%s is choosing course' %self.name)


stu1=OldboyStudent('猪哥',19,'male',1)
print(stu1.__dict__)

print(OldboyStudent.mro())

解耦合:彼此之间不影响

耦合:都结合在一起

 super严格以来继承关系

class A:
	def f1(self):
		print('A.f1')

class B:
	def f2(self):
		super().f1()
		print('B.f2')

class C(B,A):
	pass

obj=C()
print(C.mro())
obj.f2()

 1、什么是多态

　　多态指的事同一种实物的多种形态

　　水->冰，水蒸气，液态水

　　动物->人、狗、猪

2为何要用多态

　　多态性

继承同一个类的多个子类中有相同的方法名

那么子类产生的对象就可以不用考虑具体的类型而直接调用功能

python推崇的是鸭子类型，只要你叫的声音像鸭子，并且你走路的样子也像鸭子，那你就是鸭子

class Disk:
    def read(self):
        print('disk read')

    def write(self):
        print('disk wirte')

class Process:
    def read(self):
        print('process read')

    def write(self):
        print('process wirte')

class File:
    def read(self):
        print('file read')

    def write(self):
        print('file wirte')

obj1=Disk()
obj2=Process()
obj3=File()

obj1.read()
obj1.write()

今日作业：
	1、多重继承的执行顺序，请解答以下输出结果是什么？并解释。

		class A(object):
		   def __init__(self):
		       print('A')
		       super(A, self).__init__()

		class B(object):
		   def __init__(self):
		       print('B')
		       super(B, self).__init__()

		class C(A):
		   def __init__(self):
		       print('C')
		       super(C, self).__init__()

		class D(A):
		   def __init__(self):
		       print('D')
		       super(D, self).__init__()

		class E(B, C):
		   def __init__(self):
		       print('E')
		       super(E, self).__init__()

		class F(C, B, D):
		   def __init__(self):
		       print('F')
		       super(F, self).__init__()

		class G(D, B):
		   def __init__(self):
		       print('G')
		       super(G, self).__init__()

		if __name__ == '__main__':
		   g = G()
		   f = F()

	2、什么是新式类，什么是经典类，二者有什么区别？什么是深度优先，什么是广度优先？
	3、解释多态、多态性、鸭子类型
	4、定义课程类、班级类、老师类、学生类，要求如下
		1、一名老师可以带多个班级，一名学生可以属于多个班级
		2、班级绑定课程
		3、基于继承或组合减少代码冗余

	选做：按照图，实现其他类及其关系