第二十天作业

今日作业

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 和 Child2中都没有x，所以它会到父类Parent中找x,Parent类里面的x = 1， 故输出的结果都为1  
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
# 1 2 1
# 给了Child1一个x,他会优先寻找自己本身，找到了x = 2 故结果为1 2 1 
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)
# 3 2 3
# 把父类Parent的x重新赋值为3，但是并不会影响到Child1中的x，故输出结果为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-->D-->A-->B
   # 广度优先搜索，逐级往上找，直到找到A就不再找了，然后找B,因为B也是一个父类，所以会先找A再找B
   # f: F--> C-->B-->D-->A
   # 与上一个同理，知道它是广度优先就可以了

3、什么是新式类，什么是经典类，二者有什么区别？什么是深度优先，什么是广度优先？
# 只有python2中才有经典类，在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 hashlib
import datetime
class ParentClass:
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age
        self.create_id()
       # 用hashlib对当前时间加上所有信息生成唯一编号
    def create_id(self):
         m = hashlib.md5()
         time = datetime.datetime.now()
         m.update(f'{time}{self.name}{self.sex}{self.age}'.encode('utf-8'))
         self.id = m.hexdigest()
         self.save()

    # 获取所有信息
    def tell_info(self):
        print(f'''
        id: {self.id}
        name: {self.name}
        sex: {self.sex}
        age: {self.age}
        ''')

    # 将对象序列化保存到文件里，文件名即编号
    def save(self):

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

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


class Teather(ParentClass):
    def __init__(self,name,sex,age,level,sal,):
        super().__init__(name,sex,age,)
        self.level = level
        self.sal = sal
    def tell_info(self):
        print(f'''
        id: {self.id}
        name: {self.name}
        sex: {self.sex}
        age: {self.age}
        level: {self.level}
        sal: {self.sal}
        ''')

class Student(ParentClass):
    def __init__(self,name,sex,age,stu_class,course):
        super().__init__(name,sex,age,)
        self.course = course
        self.stu_class = stu_class
    def tell_info(self):
        print(f'''
        id: {self.id}
        name: {self.name}
        sex: {self.sex}
        age: {self.age}
        course: {self.course}
        stu_class: {self.stu_class}
        ''')