3/20课后总结

单继承下的属性查找

class B:
    def b1(self):
        print('B1')

    def b2(self):
        print('B2')
        self.b1()  # self是c，这句话是c.b1
        self.__b3()   # self是c，这句话是c._B__b3

    def __b3(self):  # _B__b3
        print('B3')

class C(B):
    def b1(self):  
        print('C1')

    def __b3(self):  # _C__b3
        print('C3')


c = C()
c.b2()  

"""
	单继承的查找顺序：
		先从对象名称空间找，找不到去实例化的类里找，还找不到就找父类的
		注意：一定要注意好self代表什么
"""

多继承下的属性查找

  # 菱形查找是多个类汇聚到一个点上
"""
	1. 经典类
		# 查找顺序：是按照深度优先
	2. 新式类
		# 查找顺序：是按照广度优先
"""
class G(object):
    # def test(self):
    #     print('from G')
    pass

class E(G):
    # def test(self):
    #     print('from E')
    pass

class F(G):
    # def test(self):
    #     print('from F')
    pass

class B(E):
    # def test(self):
    #     print('from B')
    pass


class C(F):
    # def test(self):
    #     print('from C')
    pass

class D(G):
    # def test(self):
    #     print('from D')
    pass

class A(B, C, D):
    # def test(self):
    #     print('from A')
    pass

obj = A()
obj.test()
"""
	1. 经典类：
		首次查找obj自己的名称空间，然后是A>>B>>E>>G>>object>>C>>F>>D
	2. 新式类:
		首次查找obj自己的名称空间，然后是A>>B>>E>>C>>F>>D>>G>>object
"""

super关键字

class Animal:
    def __init__(self,name,age):
        self.name = name
        self.age = age

class Dog(Animal):
    def __init__(self,name,age):
        # Animal.__init__(self,name,age)  # 这种调用方法，继不继承都不影响，不依赖与继承，一般不推荐这么写
        super(Dog, self).__init__(name,age)  # 不能说super就是被继承的父类，不严谨，而是根据mro列表，从当前位置往后找，不可回溯
        # super(Dog, self)返回的是一个特殊的对象

wangtao = Dog('wangtao',15)
print(wangtao.name)
print(wangtao.age)
print(Dog.mro())  # [<class '__main__.Dog'>, <class '__main__.Animal'>, <class 'object'>]
# 查看一个类的mro列表，要从起始类开始查看

多态与多态性(鸭子类型)

# 面向对象三大特征之一
# 多态就是一种事物多样性，鸟类有鸡鸭鹅，水类有固液气
import abc  # abstract class  抽象类
# 抽象类的特点：只能被继承了，不能被实例化
class Animal(metaclass=abc.ABCMeta):  # 这个类就变成了抽象类
    @abc.abstractmethod  # 方法上加上语法糖
    def speak(self):  # 类里面的方法就变成了抽象方法
        pass  # 父类里面的方法不在实现具体的功能，只是定义继承父类的子类中一定要有这个方法
class Dog(Animal):  # 继承抽象类的类
    def speak(self):  # 必须要有被抽象的方法
		pass
    
    def est(self):  # 可以有父类没有的方法
        pass
'''父类中如何限制子类中得方法名，父类中定义的方法名，在子类中一定要有，哪怕是空'''
# Animal()

'''抽象类的这种写法，python不建议写'''

组合

"""
	组合就是一个对象拥有一个属性，这个属性是另一个对象
	继承要满足什么是什么的关系
	组合是满足什么有什么的关系
	比如大黄继承狗类
	我和大黄就是组合，我可以有狗，大黄是狗
"""

class People:  # 定义一个人的父类
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender


class Student(People):  # 每个学生都有人这个父类
    def __init__(self, name, age, gender, course=None):
        if course is None:
            course = []
        super(Student, self).__init__(name, age, gender)
        self.course = course

    def __str__(self):
        return f'我是{self.name}，我今年{self.age}，我选了{self.course}'


class Teacher(People):  # 每个老师都有人这个父类
    def __init__(self, name, age, gender, level):
        self.level = level
        super(Teacher, self).__init__(name, age, gender)

    def __str__(self):
        return f'我是{self.name}，我今年{self.age}，我教{self.course.name}，课程时长是{self.course.period}，学费是{self.course.price}'


class course:  # 定义一个课程类
    def __init__(self, name, period, price):
        self.name = name
        self.period = period
        self.price = price

python = course('python','6mon','20000')  # 课程类的实例化
java = course('java','6mon','25000')  # 课程类的实例化
stu = Student('张三', 18, 'male')  # 学生的实例化
stu.course.append(java.name)  # 采用组合的方式使学生里面的一个属性course为课程类的对象
stu.course.append(python.name)
print(stu)  # 打印学生类的魔术方法__str__查看

t = Teacher('老八',32,'male','大哥')  # 老师的实例化
t.course = python  # 采用组合的方式使老师里面的一个属性course为课程类的对象
print(t)

"""
	打印结果：
		我是张三，我今年18，我选了['java', 'python']
		我是老八，我今年32，我教python，课程时长是6mon，学费是20000
"""