面向对象继承练习题

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 ：从父类继承，自己没有的就可以到父类中找,在python中,一个子类可以继承多个父类,所以child1和child2继承了parent的特征和技能。
1 2 1 ：当child1.x=2时，已经继承paernt的特征和技能，paernt.x=1父类不变，child2.x=1继承父类的值 子类child2.x=paernt。
3 2 3 ：当paernt.x = 3时，child1.x=2时已经是一个固定值，所以child2.x继承了父类的值。

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

首先是先生成一个G类的g对象,执行G内部函数,打印了G,先从G开始运行，第一个是G ，G中继承的父类是D和B，执行D类内部代码,打印了D,其中D中继承的父类是A，打印了A，因为广度优先,就先不去找最后的object类,而是返回找到G继承的B类执行B类内部代码,打印了B,最后的最后才会找到object类所以G-D-A-B,

然后从F运行，第一个是F，F中继承的父类是C,B,D，广度优先，最后是A

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

新式类:
        继承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 hashlib
import pickle
import time
hash = hashlib.md5()
class OldboyPeoPle:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.create_id()
        self.save()

    def create_id(self):
        day_time = time.strftime('%Y-%m-%d %X')
        hash = hashlib.md5()
        hash.update(bytes(day_time,encoding='utf-8'))
        self.id = hash.hexdigest() + self.name + 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 OldboyTeacher(OldboyPeoPle):
    # 等级, 薪资
    def __init__(self, name, age, sex, level, sal):
        super().__init__(name, age, sex)
        self.level = level
        self.sal = sal

    def tell_info(self):
        print(super().get_obj_by_id().__dict__)



class OldboyStudent(OldboyPeoPle):
    # 课程
    def __init__(self, name, age, sex, course):
        super().__init__(name, age, sex)
        self.course = course

    def tell_info(self):
        print(super().get_obj_by_id().__dict__)

tea1 = OldboyTeacher('liang', 20, 'gril', 8, '40k')
tea1.tell_info()
tea2 = OldboyStudent('sanmao',23,'male','python')
tea2.tell_info()

结果

{'name': 'liang', 'age': 20, 'sex': 'gril', 'id': '4f66f5abbe9832a75c5fae792164c669lianggril20'}

{'name': 'sanmao', 'age': 23, 'sex': 'male', 'id': '4f66f5abbe9832a75c5fae792164c669sanmaomale23'}