day20 作业

目录

• 今日作业
  • 1、下面这段代码的输出结果将是什么？请解释。
  • 2、多重继承的执行顺序，请解答以下输出结果是什么？并解释。
  • 3、什么是新式类，什么是经典类，二者有什么区别？什么是深度优先，什么是广度优先？
  • 4、用面向对象的形式编写一个老师类, 老师有特征：编号、姓名、性别、年龄、等级、工资，老师类中有功能。

今日作业

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
1 2 1
3 2 3
# 解释：----------------------
print(Parent.x, Child1.x, Child2.x)		打印父类、子类1、子类2的属性x：1 1 1
Child1.x = 2  修改了Child1对象（子类）名称空间中的x值，其他对象（Parent、Child2）不受影响的，打印：1 2 1
Parent.x = 3  修改了父类的名称空间的属性x值，那么子类继承父类，对应的属性值也会改变，Child1名称空间修改为2，与其他对象无关，打印：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
D
A
B
F
C
B
D
A
# 解释：----------------------
运行G() 的打印顺序：G->D->A->B
运行F() 的打印顺序：F->c->B->D->A
两者都是新式类，按照广度优先原则
g = G()：先纵观全部类-A类和B类没有继承关系，首先打印G本身，然后使用super()函数调用父类D，打印D，父类D又使用super()函数调用父类A，打印A，返回至G的第二个父类B，打印B。
f = F()：先纵观全部类-C类和D类同时继承A类，首先打印F，同理广度优先，A类将排到最后去找。

利用mro函数可以查看继承的顺序
print(G.__mro__)
print(F.__mro__)
(<class '__main__.G'>, <class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
(<class '__main__.F'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>)

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

经典类：没有继承object类的，深度优先查找
新式类：继承有object类的，广度优先查找

区别：是否继承object类，在多继承的情况下继承顺序不同

经典类是纵向查找，直接继承下去最后的一个类里面找
新式类是横向查找，会纵观全部类直到最后的一个类继承有object才去里面找

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

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

# 6、抽象老师类与学生类得到父类，用继承的方式减少代码冗余
class People(object):
    def __init__(self,name,sex,age):
        self.name = name
        self.sex =sex
        self.age = age

# 老师类
class Teacher(People):
    def __init__(self,name,sex,age,level,salary):
        super().__init__(name,sex,age)
        self.level = level
        self.salary = salary

    # 1.生成老师唯一编号的功能，
    def create_id(self):
        str = self.name + self.sex + self.age + self.level + self.salary
        self.id = hashlib.md5(str.encode("utf8")).hexdigest()
        return self.id

    # 2.获取老师所有信息
    def tell_info(self):
        info = f"""
        老师编号 {self.id}
        老师名字 {self.name}
        老师性别 {self.sex}
        老师年龄 {self.age}
        老师等级 {self.level}
        老师薪资 {self.salary}
        """
        return info

    # 3.将老师对象序列化保存到文件里，文件名即老师的编号，提示功能如下
    def save(self):
        file = f"{self.id}_{self.name}" + ".pick"
        tea_dic = {
            "name": self.name,
            "sex": self.sex,
            "age": self.age,
            "level": self.level,
            "salary": self.salary
        }
        with open(file, 'wb') as f:
            pickle.dump(tea_dic, f)

        # 文件名 9fd0ebd7fa0e6abd13066063db3a5bbb_tank.pick

    # 4.从文件夹中取出存储老师对象的文件，然后反序列化出老师对象,提示功能如下
    def get_obj_by_id(self):
        file = f"{self.id}_{self.name}" + ".pick"
        with open(file,"rb") as f:
            data = pickle.load(f)
            print(data.get("name"))

tea1 = Teacher("tank","男","18","10","3000")
# 1.生成老师唯一编号的功能，
# 可以用hashlib对当前时间加上老师的所有信息进行校验得到一个hash值来作为老师的编号
id = tea1.create_id()
print(id)

# 2.获取老师所有信息
info = tea1.tell_info()
print(info)

# 3.将老师对象序列化保存到文件里，文件名即老师的编号，提示功能如下
tea1.save()
# 4.从文件夹中取出存储老师对象的文件，然后反序列化出老师对象,提示功能如下
tea1.get_obj_by_id()

# 学生类
class Student(People):
    def __init__(self,name,sex,age,course):
        super().__init__(name,sex,age)
        self.course = course

    # 1.生成学生唯一编号的功能，
    def create_id(self):
        str = self.name + self.sex + self.age + self.course
        self.id = hashlib.md5(str.encode("utf8")).hexdigest()
        return self.id

    # 2.获取学生所有信息
    def tell_info(self):
        info = f"""
        学生编号 {self.id}
        学生名字 {self.name}
        学生性别 {self.sex}
        学生年龄 {self.age}
        学生课程 {self.course}
        """
        return info

    # 3.将学生对象序列化保存到文件里，文件名即学生的编号，提示功能如下
    def save(self):
        file = f"{self.id}_{self.name}" + ".pick"
        stu_dic = {
            "name": self.name,
            "sex": self.sex,
            "age": self.age,
            "course": self.course,
        }
        with open(file, 'wb') as f:
            pickle.dump(tea_dic, f)

    # 4.从文件夹中取出存储学生对象的文件，然后反序列化出学生对象,提示功能如下
    def get_obj_by_id(self):
        file = f"{self.id}_{self.name}" + ".pick"
        with open(file,"rb") as f:
            data = pickle.load(f)
            print(data.get("name"))

stu1 = Student("qinyj","男","18","python")
# 1.生成学生唯一编号的功能，
# 可以用hashlib对当前时间加上学生的所有信息进行校验得到一个hash值来作为学生的编号
id = stu1.create_id()
print(id)

# 2.获取学生所有信息
info = stu1.tell_info()
print(info)

# 3.将学生对象序列化保存到文件里，文件名即学生的编号，提示功能如下
stu1.save()

# 4.从文件夹中取出存储学生对象的文件，然后反序列化出学生对象,提示功能如下
stu1.get_obj_by_id()

终端打印：

9fd0ebd7fa0e6abd13066063db3a5bbb
        老师编号 9fd0ebd7fa0e6abd13066063db3a5bbb
        老师名字 tank
        老师性别 男
        老师年龄 18
        老师等级 10
        老师薪资 3000

tank

50450f287fbf32935f348f056dd088c3

        学生编号 50450f287fbf32935f348f056dd088c3
        学生名字 qinyj
        学生性别 男
        学生年龄 18
        学生课程 python

qinyj