day20の求人

今日の仕事

図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   
1 2 1
3 2 3
# 解释：----------------------
print(Parent.x, Child1.x, Child2.x)     打印父类、子类1、子类2的属性x：1 1 1  
Child1.x = 2  修改了Child1对象（子类）名称空间中的x值，其他对象（Parent、Child2）不受影响的，打印：1 2 1
Parent.x = 3  修改了父类的名称空间的属性x值，那么子类继承父类，对应的属性值也会改变，Child1名称空间修改为2，与其他对象无关，打印：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
D
A
B

F
C
B
D
A
# 解释：----------------------
运行G() 的打印顺序：G->D->A->B
运行F() 的打印顺序：F->c->B->D->A


利用mro函数可以查看继承的顺序
print(G.__mro__)
print(F.__mro__)
(<class '__main__.G'>, <class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
(<class '__main__.F'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>)

3.新しいクラスが両方とも違いは何ですか、クラシック何であるとは何ですか？深さ優先とは何ですか、幅優先は何ですか？

经典类：没有继承object类的，深度优先查找
新式类：继承有object类的，广度优先查找

区别：是否继承object类，在多继承的情况下继承顺序不同

经典类是纵向查找，直接继承下去最后的一个类里面找
新式类是横向查找，会纵观全部类直到最后的一个类继承有object才去里面找

4、オブジェクト指向形式のクラスで先生の調製は、教師は特性があります。番号、名前、性別、年齢、学年、給与、教師はクラスの機能を持っています。

'''
用面向对象的形式编写一个老师类, 
老师有特征：编号、姓名、性别、年龄、等级、工资，老师类中有功能。
1.生成老师唯一编号的功能，
可以用hashlib对当前时间加上老师的所有信息进行校验得到一个hash值来作为老师的编号
2.获取老师所有信息
3.将老师对象序列化保存到文件里，文件名即老师的编号，提示功能如下
4.从文件夹中取出存储老师对象的文件，然后反序列化出老师对象,提示功能如下
5、按照定义老师的方式，再定义一个学生类
'''
import pickle
import hashlib


# 6、抽象老师类与学生类得到父类，用继承的方式减少代码冗余
class People(object):
    def __init__(self,name,sex,age):
        self.name = name
        self.sex =sex
        self.age = age

# 老师类
class Teacher(People):
    def __init__(self,name,sex,age,level,salary):
        super().__init__(name,sex,age)
        self.level = level
        self.salary = salary

    # 1.生成老师唯一编号的功能，
    def create_id(self):
        str = self.name + self.sex + self.age + self.level + self.salary
        self.id = hashlib.md5(str.encode("utf8")).hexdigest()
        return self.id

    # 2.获取老师所有信息
    def tell_info(self):
        info = f"""
        老师编号 {self.id}
        老师名字 {self.name}
        老师性别 {self.sex}
        老师年龄 {self.age}
        老师等级 {self.level}
        老师薪资 {self.salary}
        """
        return info

    # 3.将老师对象序列化保存到文件里，文件名即老师的编号，提示功能如下
    def save(self):
        file = f"{self.id}_{self.name}" + ".pick"
        tea_dic = {
            "name": self.name,
            "sex": self.sex,
            "age": self.age,
            "level": self.level,
            "salary": self.salary
        }
        with open(file, 'wb') as f:
            pickle.dump(tea_dic, f)

        # 文件名 9fd0ebd7fa0e6abd13066063db3a5bbb_tank.pick

    # 4.从文件夹中取出存储老师对象的文件，然后反序列化出老师对象,提示功能如下
    def get_obj_by_id(self):
        file = f"{self.id}_{self.name}" + ".pick"
        with open(file,"rb") as f:
            data = pickle.load(f)
            print(data.get("name"))

tea1 = Teacher("tank","男","18","10","3000")
# 1.生成老师唯一编号的功能，
# 可以用hashlib对当前时间加上老师的所有信息进行校验得到一个hash值来作为老师的编号
id = tea1.create_id()
print(id)

# 2.获取老师所有信息
info = tea1.tell_info()
print(info)

# 3.将老师对象序列化保存到文件里，文件名即老师的编号，提示功能如下
tea1.save()
# 4.从文件夹中取出存储老师对象的文件，然后反序列化出老师对象,提示功能如下
tea1.get_obj_by_id()





# 学生类
class Student(People):
    def __init__(self,name,sex,age,course):
        super().__init__(name,sex,age)
        self.course = course

    # 1.生成学生唯一编号的功能，
    def create_id(self):
        str = self.name + self.sex + self.age + self.course
        self.id = hashlib.md5(str.encode("utf8")).hexdigest()
        return self.id

    # 2.获取学生所有信息
    def tell_info(self):
        info = f"""
        学生编号 {self.id}
        学生名字 {self.name}
        学生性别 {self.sex}
        学生年龄 {self.age}
        学生课程 {self.course}
        """
        return info

    # 3.将学生对象序列化保存到文件里，文件名即学生的编号，提示功能如下
    def save(self):
        file = f"{self.id}_{self.name}" + ".pick"
        tea_dic = {
            "name": self.name,
            "sex": self.sex,
            "age": self.age,
            "course": self.course,
        }
        with open(file, 'wb') as f:
            pickle.dump(tea_dic, f)


    # 4.从文件夹中取出存储学生对象的文件，然后反序列化出学生对象,提示功能如下
    def get_obj_by_id(self):
        file = f"{self.id}_{self.name}" + ".pick"
        with open(file,"rb") as f:
            data = pickle.load(f)
            print(data.get("name"))

stu1 = Student("qinyj","男","18","python")
# 1.生成学生唯一编号的功能，
# 可以用hashlib对当前时间加上学生的所有信息进行校验得到一个hash值来作为学生的编号
id = stu1.create_id()
print(id)

# 2.获取学生所有信息
info = stu1.tell_info()
print(info)

# 3.将学生对象序列化保存到文件里，文件名即学生的编号，提示功能如下
stu1.save()

# 4.从文件夹中取出存储学生对象的文件，然后反序列化出学生对象,提示功能如下
stu1.get_obj_by_id()

ターミナル印刷：

9fd0ebd7fa0e6abd13066063db3a5bbb
        老师编号 9fd0ebd7fa0e6abd13066063db3a5bbb
        老师名字 tank
        老师性别 男
        老师年龄 18
        老师等级 10
        老师薪资 3000

tank


50450f287fbf32935f348f056dd088c3

        学生编号 50450f287fbf32935f348f056dd088c3
        学生名字 qinyj
        学生性别 男
        学生年龄 18
        学生课程 python
        
qinyj