python06.19

1.类的继承

继承是一种新建类的方式，新建的类称为子类被继承的类称为父类

继承的特性，子类会遗传父类的属性

继承是类与类之间的关系,继承减少了代码的冗杂

class Parent_Foo:
    def__init__(self,first_name,money,car,house):
        self.first_name = first_name
        self.money = money*0.5
        self.car = car
        self.house = house
        
    def find_wife(self):
        print(f'{self.first_name}先生找到妻子白富美')

class Son_Foo(Parent_Foo):
    pass

对象查找属性的顺序：对象自己-》对象的类-》父类-》父类。。。

class Foo:
    def f1(self):
        print('Foo.f1')
        
    def f2(self):
        print('Foo.f2')
        self.f1()
class Bar(Foo):
    def f1(self):
        print('Bar.f1')
        
obj = Bar()
obj.f2()

2.类的派生

派生：子类中新定义的属性的这个过程叫做派生，子类在使用派生的时候以自己为主。

#派生方法一；
class OldBoyPeople:
    school = 'oldboy'
    
    def __init__(self,name,age,gender)
    self.name = name
    self.age = age
    self.gender = gender
    
class OldBoyStudent(OldBoyPeople):
    def choose_course(self):
        print('%s is choosing course % self.name')

class OldBoyTeacher(OldBoyPeople):
    def __init__(self,name,age,gender,level):
        OldBoyPeople.__init__(self,name,age,gender)
        self.level = level  #派生
        
    def score(self,stu_obj,num):
        print('%s is scoring' % self.name)
        stu_obj.score = num
        
stu1 = OldBoyStudent('tank',18,'male')
tea1 = OldBoyStudent('nick',18,'male',10)

print(stu1.__dict__)
print(tea1.__dict__)

#派生方法二
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)
    super().__init__(name,age,sex)
    self.stu_id = stu_id
    
    def choose_course(self):
        print('%s is choosing course' % self.name)
        
atu1 = OldBoyStudent('tank',19,'male',1)

print((atu1.__dict__))

3.组合

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

class People:
    def __init__(self,name,gender):
        self.name = name
        self.gender = gender
    def sleep(self):
        pring(f'{self.name}睡着了')
        
class Student(People):
    def __init__(self,student_id,name,gender):
        self.student_id = student_id
        super(Student,self).__init__(name,gender)
        
    def choose_course(self,course):
        self.course = course
        print(f'{self.name}选课{course.name}成功')
        
class Teacher(People):
    def __init__(self,level,name,gender):
        self.level = level
        super(Teacher,self).__init__(name,gender)
        
    def scored(self,student,course,score):
        print(f'老师{self.name}给{student.name}课程{course.name}打分{score}')
        
class Course:
    def __init__(self,name,price):
    self.name = name
    self.price = price
    
class Admin(People):
    def create_course(self,name,price):
        course =Course(name,price)
        print(f'管理员{self.name}创建了课程{name}')
        return course
#定义课程
python = Course('Python','8888')
linux = Course('Linux','6666')

#定义学生
students1 = Student('01','students1','female')
students2 = Student('02','Students2','male')

#定义老师
nick = Teacher('1','nick','male')
tank = Teacher('2','tank','female')

# 管理员
egon = Admin('egon','male')

#业务逻辑
python = egon.create_course('python','8888')
print(python.__dict__)
linux = egon.create_course('linux','6666')
print(linux.__dict__)

#选择课程
students1.choose_couse(python)

#得分
nick.scored(students1,python,'0')

4.菱形继承问题

在python3中会默认继承object类，继承了object类的称为新式类

在python2中不会默认继承object类，需手动添加，没有继承object类的就是经典类

当继承为菱形继承时，经典类与新式类搜索某一个属性的顺序会不一样

在新式类中，当遇到菱形继承时，会以广度优先查找

在经典类中，当遇到菱形继承时，会以深度优先查找

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

class E(G):
    def test(self):
        print('from E')    
        
class D(G):
    def test(self):
        print('from D')
        
class C(F):
    def test(self):
        print('from C')
        
class B(E):
    def test(self):
        print('from B')
        
class A(B,C,D):
    def test(self):
        print('from A')
        
a = A()        
a.test()
for i in A.__mro__:
    print(i)

5.类的多态与继承

多态指的是一类事物有多种形态(一个抽象类有多个子类)

多态性：一种调用方式，不同的执行效果。

import abc
class Animal(metaclass=abc.ABCMeta):
    def __init__(self,height,weight):
        self.height = height
        self.weight = weight
   @abc.abstractmethod
	def sleep(self):
        print('在睡觉')
    
   @abc.abstractmethod
	def speak(self):
        print(self,'开始叫了')
   @abc.abstractmethod
	def eat(self):
        print(self,'开始吃了')
        
        
class Dog(Animal):
    def speak(self):
        print('开始叫了')
        
    def eat(self):
        print('开始吃了')
        
dog = Dog(50,100)