今日作业

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

class Parent(object):
  	x = 1

class Child1(Parent):
    pass

class Child2(Parent):
    pass

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

对象查找属性顺序：对象---> 子类---> 父类---->object

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
'''

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的类都是新式类
• 经典类：在python2中，凡是没有继承object的类都是经典类

两者区别：只有在python2中才有新式类和经典类的区分，在python3中都是新式类

深度优先：经典类的查找顺序，一条道走到黑

广度优先：新式类的查找顺序，不找到最后的父类，返回来找，最后找父类。

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

要求：
1.生成老师唯一编号的功能，可以用hashlib对当前时间加上老师的所有信息进行校验得到一个hash值来作为老师的编号
2.获取老师所有信息
3.将老师对象序列化保存到文件里，文件名即老师的编号
4.从文件夹中取出存储老师对象的文件，然后反序列化出老师对象
5、按照定义老师的方式，再定义一个学生类
6、抽象老师类与学生类得到父类，用继承的方式减少代码冗余

import hashlib
import pickle


class People:
    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

    # 生成老师唯一编号的功能
    def create_id(self):
        password_str = str(self.name) + str(self.sex) + str(self.level) + str(self.salary)
        id = hashlib.md5()
        id.update(password_str.encode('utf-8'))
        id = id.hexdigest()
        return id

    # 获取老师所有信息
    def tell_info(self):
        print(f'''老师所有信息：
            编号：{self.create_id()}
            姓名：{self.name}
            性别：{self.sex}
            年龄：{self.age}
            等级：{self.level}
            工资：{self.salary}
            ''')

    # 将老师对象序列化保存到文件里，文件名即老师的编号
    def save(self):
        file_name = f'{self.create_id()}'

        msg_dic = {
            'name': self.name,
            'sex': self.sex,
            'age': self.age,
            'level': self.level,
            'salary': self.salary
        }

        with open(file_name, 'wb') as f:
            pickle.dump(msg_dic, f)

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


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

    # 生成学生唯一编号的功能
    def create_id(self):
        password_str = str(self.name) + str(self.sex) + str(self.course)
        id = hashlib.md5()
        id.update(password_str.encode('utf-8'))
        id = id.hexdigest()
        return id

    # 获取学生所有信息
    def tell_info(self):
        print(f'''学生所有信息：
            编号：{self.create_id()}
            姓名：{self.name}
            性别：{self.sex}
            年龄：{self.age}
            课程：{self.course}
            ''')

    # 将学生对象序列化保存到文件里，文件名即学生的编号
    def save(self):
        file_name = f'{self.create_id()}'

        msg_dic = {
            'name': self.name,
            'sex': self.sex,
            'age': self.age,
            'course': self.course
        }

        with open(file_name, 'wb') as f:
            pickle.dump(msg_dic, f)

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


# 实例化一个老师对象
t1 = Teacher('tank', 'male', 18, 9, 3.0)
# 调用create_id
id = t1.create_id()
print(id)

t1.tell_info()
# t1.save()
res = t1.get_obj_by_id()
print(res)


# 实例化一个学生对象
s1 = Student('小明', 'male', 18, 'python')

id = s1.create_id()
print(id)

# s1.save()

s1.tell_info()

print(s1.get_obj_by_id())