继承与派生

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

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

Parent.x指向该类的值1，Child1.x先查找class Child1中是否有x的值，若没有，则再查找它的父类parent，值为1，Child2的值同

1 2 1

Child1.x =值赋值为2，Parent.x值为1，Child1.x已经被赋值2，Child2.x中没有x的值，查找父类，x==1

3 2 3

和第二行打印输出的原理相同

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

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():object--新式类--广度优先

G ->D-->A-->B

f = F():object--新式类--广度优先

F-->C-->B-->D-->A

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

新式类：

继承object的类都是新式类，在python3中，子类不继承自定义的类，默认继承object

经典类：

在python2 中，凡是没有继承object的类都是经典类

深度优先：经典式--就是指一棵树，直接搜寻到叶节点，再原路返回搜索其他的叶节点（类的继承中，按照继承的顺序查找至叶节点，在原路返回搜寻其他叶节点）

广度优先：新式类就是指一棵树，当下一个节点是公共叶节点的时候，停止搜寻原路返回再搜寻下一个，直到只含有一个叶节点

（若是公共叶节点，则搜寻最后一条分支的叶节点时，再读出该公共叶节点）

4、用面向对象的形式编写一个老师类, 老师有特征：编号、姓名、性别、年龄、等级、工资，老师类中有功能。

1.生成老师唯一编号的功能，可以用hashlib对当前时间加上老师的所有信息进行校验得到一个hash值来作为老师的编号

def create_id(self):
    pass

2.获取老师所有信息

def tell_info(self):
    pass

3.将老师对象序列化保存到文件里，文件名即老师的编号，提示功能如下

def save(self):
    with open('老师的编号','wb') as f:
        pickle.dump(self,f)

4.从文件夹中取出存储老师对象的文件，然后反序列化出老师对象,提示功能如下

def get_obj_by_id(self,id):
    return pickle.load(open(id,'rb'))

5、按照定义老师的方式，再定义一个学生类

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

import pickle
import datetime
import hashlib


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

    def creat_id(self):
        """生成老师唯一编号 hashlib"""
        now = datetime.datetime.now()
        msg = f'{now}{self.age}{self.name}{self.sex}'
        m = hashlib.md5()
        m.update(msg.encode('utf8'))
        return m.hexdigest()


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

    def tell_info(self):
        """获取老师所有信息"""
        get_all_info = {
            'id': self.creat_id(),
            'age': self.age,
            'name': self.name,
            'sex': self.sex,
            'level': self.level,
            'money': self.money
        }
        return get_all_info

    def save(self):
        """序列化保存老师编号"""
        id = self.creat_id()
        with open(f'{id}.pkl', 'wb') as filew:
            pickle.dump(self.tell_info(), filew)
        self.get_obj_by_id(id)

    def get_obj_by_id(self, id):
        """从文件夹中获取老师"""
        with open(f'{id}.pkl', 'rb') as filer:
            m = pickle.load(filer)
            print('name:' + m['name'])
            print(m)


class Student(People):
    def __init__(self, age, name, sex, Grade, score):
        super().__init__(age, name, sex)
        self.Grade = Grade
        self.score = score

    def tell_info(self):
        """获取老师所有信息"""
        get_all_info = {
            'id': self.creat_id(),
            'age': self.age,
            'name': self.name,
            'sex': self.sex,
            'Grade': self.Grade,
            'score': self.score
        }
        return get_all_info

    def save(self):
        """序列化保存编号"""
        id = self.creat_id()
        with open(f'{id}.pkl', 'wb') as filew:
            pickle.dump(self.tell_info(), filew)
        self.get_obj_by_id(id)

    def get_obj_by_id(self, id):
        """从文件夹中获取编号"""
        with open(f'{id}.pkl', 'rb') as filer:
            m = pickle.load(filer)
            print('name:' + m['name'])
            print(m)

if __name__ == "__main__":
    tea1 = Teacher(30, '张', '男', '高级', 10000)
    tea1.save()
    stu1 = Student(18, '李', '男', 3, 100)
    stu1.save()

运行结果：