day 20 作业

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	# 此时所有子类都没有x,只能去父类中找,所以都是父类的x,此时父类x=1
1 2 1	# 这时修改Child1的x,所以只有Child1中的x改变了
1 2 3	# 这时Child2d的x也被修改了,但Child1中的x在上面已经被改过,所以对比上行的输出只有Child2改变

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最先调用G类所以先从G中运行打印G
D  # 由于G先继承了D,所以这是找到了D类,打印D
A  # 由于D又继承了A ,所以找到了A类,打印A
B  # 这时G继承的第一个D类找完了,接着找第二个继承的类B,并打印B
F  # 这时g已经结束,f调用了F类,打印F
C  # F第一个继承的父类为C,所以找到了C,并打印C
B  # 此时虽然C继承了A类,但是后面一个父类D也继承了A类,此时python3遵循广度优先所以并没有打印A,而是找第二个继承的父类B,打印B
D  # 这时回来继续找第三个父类D,打印D
A  # D类继承了A类,打印A

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

新式类就是继承了object的类,经典类就是python2中没有继承object的类,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、按照定义老师的方式，再定义一个学生类
    

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

# 老师类
import hashlib
import time
import pickle


class Teacher:
   
    def __init__(self, number, name, sex, age, grade, salary):
        self.unmber = number
        self.name = name
        self.sex = sex
        self.age = age
        self.grade = grade
        self.salary = salary

    # 1.生成老师唯一编号的功能，可以用hashlib对当前时间加上老师的所有信息进行校验得到一个hash值来作为老师的编号
    def create_id(self):
        md5 = hashlib.md5()
        creat_teacher_id = f'{self.unmber},{self.name},{self.sex},{self.age},{self.grade},{self.salary}'
        day_time = time.strftime("%Y-%m-%d %X")
        creat_id = creat_teacher_id + day_time
        md5.update(creat_id.encode('utf8'))
        self.id = md5.hexdigest()
        print(self.id)
        return self.id

    # 2.获取老师所有信息 
    def tell_info(self):
        self.teacher_msg = f'编号:{self.unmber}
姓名:{self.name}
性别{self.sex}
年龄:{self.age}
等级:{self.grade}
工资:{self.salary}'
        return self.teacher_msg

    # 3.将老师对象序列化保存到文件里，文件名即老师的编号
    def save(self):
        with open(f'{Teacher.create_id(self)}.pkl', 'wb') as f:
            pickle.dump(self, f)

    # 4.从文件夹中取出存储老师对象的文件，然后反序列化出老师对象
    def get_obj_by_id(self, id):
        return pickle.load(open(f'{id}.pkl','rb'))
    
    
    
    
    
    # 5、按照定义老师的方式，再定义一个学生类
    
    class Student:
    def __init__(self, number, name, sex, age):
        self.unmber = number
        self.name = name
        self.sex = sex
        self.age = age


    def create_id(self):
        md5 = hashlib.md5()
        creat_teacher_id = f'{self.unmber},{self.name},{self.sex},{self.age}'
        day_time = time.strftime("%Y-%m-%d %X")
        creat_id = creat_teacher_id + day_time
        md5.update(creat_id.encode('utf8'))
        self.id = md5.hexdigest()
        print(self.id)
        return self.id

    def tell_info(self):
        self.teacher_msg = f'编号:{self.unmber}
姓名:{self.name}
性别{self.sex}
年龄:{self.age}'
        return self.teacher_msg

    def save(self):
        with open(f'{Student.create_id(self)}.pkl', 'wb') as f:
            pickle.dump(self, f)

    def get_obj_by_id(self, id):
        return pickle.load(open(f'{id}.pkl','rb'))
    
    
    
    # 6、抽象老师类与学生类得到父类，用继承的方式减少代码冗余
    class School:
    def __init__(self, number, name, sex, age):
        self.unmber = number
        self.name = name
        self.sex = sex
        self.age = age

    def create_id(self):
        md5 = hashlib.md5()
        creat_teacher_id = f'{self.unmber},{self.name},{self.sex},{self.age}'
        day_time = time.strftime("%Y-%m-%d %X")
        creat_id = creat_teacher_id + day_time
        md5.update(creat_id.encode('utf8'))
        self.id = md5.hexdigest()
        print(self.id)
        return self.id

    def tell_info(self):
        self.School_msg = f'编号:{self.unmber}
姓名:{self.name}
性别{self.sex}
年龄:{self.age}'
        return self.School_msg

    def save(self):
        with open(f'{School.create_id(self)}.pkl', 'wb') as f:
            pickle.dump(self, f)

    def get_obj_by_id(self, id):
        return pickle.load(open(f'{id}.pkl','rb'))