days20

下面这段代码的输出结果将是什么？请解释

class Parent(object):
    x = 1

class Child1(Parent):
    pass

class Child2(Parent):
    pass

print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)

'''
1 1 1
1 2 1
3 2 3

继承背景下对象属性的查找顺序：对象查找属性会先从对象的名称空间中查找-->若对象没有,则会去类里面找-->若当前类是子类,并且没有对象找的属性,会去父类中查找

一开始Child1，Child2都没有对应的对象属性，都是去父类Parent，之后Child1.x = 2被赋值了，就不用找父类Parent查找，Child2还是没有对应的对象属性，依然去父类Parent查找，父类Parent改变，Child2也相应改变

'''

多重继承的执行顺序，请解答以下输出结果是什么？并解释。

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()

'''
g = G()     G-->D-->A-->B

f = F()     F-->C-->B-->D-->A

在python3中,子类不继承自定义的类,默认继承object,所有的类都是新式类,新式类广度优先
'''

什么是新式类，什么是经典类，二者有什么区别？什么是深度优先，什么是广度优先

'''
新式类:
        继承object的类都称之为新式类.

经典类:
        在python2中,凡是没有继承object的类都是经典类.
        
区别：有没有继承object的类  

深度优先: 先找多继承的第一个,一条路走到黑,一直找到最后,再返回找多继承的第二个

广度优先: 不找多各类最后继承的同一个类，直接去找下一个父类，形状类似棱形
        
'''

面向对象的形式编写

'''
用面向对象的形式编写一个老师类, 老师有特征：编号、姓名、性别、年龄、等级、工资，老师类中有功能。
1.生成老师唯一编号的功能，可以用hashlib对当前时间加上老师的所有信息进行校验得到一个hash值来作为老师的编号
2.获取老师所有信息
3.将老师对象序列化保存到文件里，文件名即老师的编号
4.从文件夹中取出存储老师对象的文件，然后反序列化出老师对象
'''

import pickle
import datetime
import hashlib

class Teacher:

    def __init__(self,name, age, sex, level, sal,teacher_id=None):
        self.name = name
        self.age = age
        self.sex = sex
        self.level = level
        self.sal = sal
        self.teacher_id = teacher_id

    # 生成老师唯一编号的功能
    def create_id(self):
        msg = f'{datetime.datetime.now()}+{self.name}+{self.sex}+{self.age}'
        self.teacher_id = hashlib.md5(msg.encode('utf-8')).hexdigest()
        return  self.teacher_id

    # 获取老师所有信息
    def tell_info(self):
        return self.__dict__

    # 将老师对象序列化保存到文件里，文件名即老师的编号
    def save(self):
        with open(f'{self.teacher_id}', 'wb') as f:
            pickle.dump(self, f)

    # 从文件夹中取出存储老师对象的文件，然后反序列化出老师对象
    def get_obj_by_id(self):
        return pickle.load(open(f'{self.teacher_id}', 'rb'))

# 按照定义老师的方式，再定义一个学生类
class Student:
    def __init__(self, name, age, sex, course, teacher_id=None):
        self.name = name
        self.age = age
        self.sex = sex
        self.course = course
        self.teacher_id = teacher_id
    
    # 生成学生唯一编号的功能
    def create_id(self):
        msg = f'{datetime.datetime.now()}+{self.name}+{self.sex}+{self.age}'
        self.student_id = hashlib.md5(msg.encode('utf-8')).hexdigest()
        return  self.student_id        
        
    # 将学生对象序列化保存到文件里，文件名即学生的编号
    def save(self):
        with open(f'{self.student_id}', 'wb') as f:
            pickle.dump(self, f)

    # 从文件夹中取出存储老师对象的文件，然后反序列化出学生对象
    def get_obj_by_id(self):
        return pickle.load(open(f'{self.student_id}', 'rb'))        

    # 学生可以选择课程
    def choose_course(self, course):
        print(f'学生[{self.name}]选择课程[{course}]')

# 抽象老师类与学生类得到父类，用继承的方式减少代码冗余
class People:

    def __init__(self, name, age, sex, people_id=None):
        self.name = name
        self.age = age
        self.sex = sex
        self.people_id = people_id
        self.create_id()
        self.save()
        self.get_obj_by_id()

    def create_id(self):
        msg = f'{datetime.datetime.now()}+{self.name}+{self.sex}+{self.age}'
        self.people_id = hashlib.md5(msg.encode('utf-8')).hexdigest()
        return  self.people_id
    
    def save(self):
        with open(f'{self.people_id}', 'wb') as f:
            pickle.dump(self, f)
            
    def get_obj_by_id(self):
        return pickle.load(open(f'{self.people_id}', 'rb'))
    

class Teacher(People):
    def __init__(self, name, age, sex, level, salary, people_id=None):
        super().__init__(name, age, sex, people_id=None)
        self.level = level
        self.salary = salary

    def tell_info(self):
        return self.__dict__
    
    
class Student(People):
    def __init__(self, name, age, sex, course, people_id=None):
        super().__init__(name, age, sex, people_id=None)
        self.course = course

  def choose_course(self, course):
        print(f'学生[{self.name}]选择课程[{course}]')
        
        
        
        

tea1 = Teacher('tank', 17 , 'male', 1 , 6000)
print(tea1.name)
stu1 = Student('jzm', 20 , 'male', 'python')