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的变量=1，Child1.x继承了父类中的x=1，Child2.x继承了父类中的x=1
1 2 1#父类下x的变量=1，Child1.x派生类x=2，Child2.x继承了父类中的x=1
3 2 3#派生类Parent.x = 3，Child1.x派生类x=2，派生类Parent.x = 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
'''

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

新式类：继承了object的类以及该类的子类，都是新式类

经典类：没有继承object的类以及该类的子类，都是经典类

区别：python3中所有的类都是新式类，子类不继承自定义的类，默认继承object

​ 只有python2中才有经典类

经典类：

​ 深度优先：一直下去
​ 经典类多继承搜索顺序(深度优先):
​ 先深入继承树左侧查找，然后再返回，开始查找右侧

新式类：

​ 广式优先：多继承搜索顺序(广度优先):
​ 先在水平方向查找，然后再向上查找，

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

1.生成老师唯一编号的功能，可以用hashlib对当前时间加上老师的所有信息进行校验得到一个hash值来作为老师的编号
			def create_id(self):
				now = time.strftime('%Y-%m-%d---%X')
				info=self.name+self.sex+str(self.age)+str(self.level)+str(self.salary)
				res=hashlib.md5((now+info).encode('utf-8'))
				self.id=res.hexdigest()
				return self.id
2.获取老师所有信息
		def tell_info(self):
			print(('Info of %s'%(self.name)).center(50,'-'))
			print('''
			编号：%s
			姓名：%s
			性别：%s
			年龄：%s
			等级：%s
			薪资：%s
			'''%(
			self.id,self.name,self.sex,self.age,self.level,self.salary))
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、按照定义老师的方式，再定义一个学生类
class Student:
	def __init__(self,name,sex,age,course):
	self.name=name
	self.sex=sex
	self.age=age
	self.course=course

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

import pickle
import hashlib
import time


class Teacher:
    def __init__(self, name, sex, age, level, salary):
        self.name = name
        self.age = age
        self.sex = sex
        self.level = level
        self.salary = salary

    def create_id(self):
        now = time.strftime('%Y-%m-%d---%X')
        info = self.name + self.sex + str(self.age) + str(self.level) + str(self.salary)
        res = hashlib.md5((now + info).encode('utf-8'))
        self.id = res.hexdigest()
        return self.id

    def tell_info(self):
        print((' Info of %s ' % (self.name)).center(50, '-'))
        print('''
    编号: %s
    姓名: %s
    性别: %s
    年龄: %s
    等级: %s
    薪资: %s
        ''' % (
            self.id, self.name, self.sex, self.age, self.level, self.salary))

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


t1 = Teacher('Catalog Spri', 'male', 18, 10, 3.1)
t1.create_id()
t1.tell_info()
t1.save()
res = t1.get_obj_by_id()
print(res)