作业20

今日作业

1、下面这段代码的输出结果将是什么？请解释。
class Parent(object):
    x = 1

class Child1(Parent):
    pass

class Child2(Parent):
    pass

print(Parent.x, Child1.x, Child2.x)
# 打印结果分别为： 1  1  1
# x为Parent的属性，所以Parent.x 直接打印 x 的值； Child1 和 Child2 都继承了Parent的属性，所以Child1.x 和 Child2.x 他们都会在各自的名称空间中找x，都找不到，然后都到父类Parent的名称空间找，找到了x，然后打印出结果

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

# 打印结果分别为： 1  2  1
# Child1.x = 2 ，这句话先为 Child1 自己添加了属性 x ，然后都先在自己的名称空间中找 x ，Parent 和 Child1 中有x，直接打印x的值，Child2 的名称空间中没有就去父类里找x，父类有，打印x的值

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

# 打印结果分别为： 3  2  3
# Parent.x = 3 Parent修改了自己属性 x 的值 ，然后都先在自己的名称空间中找 x ，Parent 和 Child1 中有x，直接打印x的值，Child2 的名称空间中没有就去父类里找x，父类有，打印x的值

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 D A B F C B D A
     g = G()：# G D A B
     f = F()：# F C B D A
解释： 按照新式类的广度优先 继承顺序 ， 
      G 的继承顺序为： G-> D->->A->B
      F 的继承顺序为： F->C->B->D->A
      在多继承的情况下，对象的查找顺序为先查找 对象自己，再查找 实例化这个对象的类，之后按照这个类的继承顺序查找 各个父类，在查找的过程中会调用各个内内部的`__init__`函数，依次执行函数内部的代码。
    
3、什么是新式类，什么是经典类，二者有什么区别？什么是深度优先，什么是广度优先？

# 答：新式类是继承了object的类，经典类是没有继承object的类，python2才有新式类和经典类的区分，python3中都是新式类。
# 深度优先和广度优先都是一种继承父类时的参照规则，在多继承的情况下，新式类的继承顺序以广度优先 的规则继承父类。而经典类以深度优先 的规则继承父类。
#深度优先下，先继承顶层的父类，广度优先下，最后继承顶层的父类，再继承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、按照定义老师的方式，再定义一个学生类
import hashlib
import datetime
import pickle
class Teacher:
    def __init__(self, name, sex, age, level, salary):
        self.name = name
        self.sex = sex
        self.age = age
        self.level = level
        self.salary = salary
    #第一题
    def create_id(self):
        time_now = datetime.datetime.now()
        time_str = time_now.strftime('%Y-%m-%d %X')
        counts = time_str + self.name + self.sex + str(self.age) + str(self.level) + str(self.salary)
        m = hashlib.md5()
        m.update(counts.encod('utf-8'))
        self.id = m.hexdigest()
    #第二题
    def tell_info(self):
        print(self.id, self.name, self.sex, self.age, self.level, self.salary)
    #第三题
    def save(self):
        with open(f'{self.id}', 'wb') as fwb:
            pickle.dump(self, fwb)
    #第四题
    def get_obj_by_id(self, id):
        with open(id, 'rb')as frb:
            return pickle.load(frb)

# 第五题
import hashlib
import datetime
import pickle

class Student:
    def __init__(self, name, sex, age, course ):
        self.name = name
        self.sex = sex
        self.age = age
        self.course = course
        
    def create_id(self):
        time_now = datetime.datetime.now()
        time_str = time_now.strftime('%Y-%m-%d %X')
        counts = time_str + self.name + self.sex + str(self.age) + str(self.course) 
        m = hashlib.md5()
        m.update(counts.encod('utf-8'))
        self.id = m.hexdigest()

    def tell_info(self):
        print(self.id, self.name, self.sex, self.age, self.course)

    def save(self):
        with open(f'{self.id}', 'wb') as fwb:
            pickle.dump(self, fwb)

    def get_obj_by_id(self, id):
        with open(id, 'rb')as frb:
            return pickle.load(frb)
6、抽象老师类与学生类得到父类，用继承的方式减少代码冗余

import hashlib
import datetime
import pickle

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

    def create_id(self):
        time_now = datetime.datetime.now()
        time_str = time_now.strftime('%Y-%m-%d %X')
        counts = time_str + self.name + self.sex + str(self.age) + str(self.level) + str(self.salary)
        m = hashlib.md5()
        m.update(counts.encod('utf-8'))
        self.id = m.hexdigest()

    def tell_info(self):
        print(self.id, self.name, self.sex, self.age,end='')

    def save(self):
        with open(f'{self.id}', 'wb') as fwb:
            pickle.dump(self, fwb)

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


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

    def tell_info(self):
        print(super().tell_info(), self.level, self.salary)


class Student(Parent):
    def __init__(self, name, sex, age, course):
        super().__init__(name, sex, age)
        self.course = course

    def tell_info(self):
        print(super().tell_info(), self.course)