day_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，就去父类找，找到了所以三个都是1 1 1 
Child1.x = 2
print(Parent.x, Child1.x, Child2.x) # 1 2 1
#在子类child1中定义类x=2 对象在子类先找到了2就不去父类找了 所以三个输出是121
Parent.x = 3
print(Parent.x, Child1.x, Child2.x) # 3 2 3
#父类中重新定义了x=3 子类child2依然没有定义，所以 323



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>D>A>B
#g=G()调用类G G输入G，再通过super得到父类的名称空间，再去调用父类D，输入D，类D又通过super调用类A输出A，再返回类G通过super调用B 最后输出B

#f=F() F>C>A>B>D>A
#同理得

3、什么是新式类，什么是经典类，二者有什么区别？什么是深度优先，什么是广度优先？
	在python2中才有新式类与经典类之分
	在python3中所有的类都是新式类
    
    ### 新式类：

	继承object的类都称之为新式类

	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

from datetime import datetime


class BaseClass(object):
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
        self.create_id()
        self.save()

    def create_id(self):
        # self.id = str(hash(str(time.time())))
        res = datetime.today().strftime('%Y-%m-%d %X')
        m = hashlib.md5()
        m.update(bytes(res, encoding='utf-8'))
        self.id = str(m.hexdigest()) + str(self.name) + str(self.sex) + str(self.age)
        self.save()

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

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


class Teacher(BaseClass):
    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().get_obj_by_id().__dict__)


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


t1 = Teacher('tank', 'female', 93, 1, 100)
print(t1.get_obj_by_id().__dict__)

s1 = Student('mqb', 'male', 18, 'python')
print(s1.get_obj_by_id().__dict__)

t1.tell_info()