第063讲：类和对象（VI）| 课后测试题及答案

叶常歌

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

囧覅
请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

懋鼕

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

tanshuizhu

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：同一符号、同一函数可实现不同功能

第 1 题的答案是：

第 2 题的答案是：是

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：不是

-------- 动动手 --------

请将第 0 题的代码写在下方：

735146730

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：
可以
第 3 题的答案是：
When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.
第 4 题的答案是：
降低了耦合度
第 5 题的答案是：
不属于
-------- 动动手 --------

请将第 0 题的代码写在下方：

gigi.wudan

keep going！

7ashni

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

帅先森

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

雨明

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：+ * len

第 1 题的答案是：可以处理不同的场景

第 2 题的答案是：可以

第 3 题的答案是：一只鸟走起来像鸭子，叫起来像鸭子，那他就是鸭子

第 4 题的答案是：降低了耦合度

第 5 题的答案是：不属于

-------- 动动手 --------

请将第 0 题的代码写在下方：
#基类员工
class Staff:
    def __init__(self,uid,name,job,grade,year):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
        self.uid = uid

    def get_uid(self):
        #获取工号
        return self.uid

    def get_name(self):
        #获取姓名
        return self.name

    def get_job(self):
        #获取职位
        return self.job

    def get_grade(self):
        #获取级别
        return self.grade

    def get_year(self):
        #获取工龄
        return self.year

    def salary(self):
        #抽象方法，在子类中实现
        raise NotImplementedError("Subclass must implement abstract method")

#普通员工
class Employee(Staff):
    def __init__(self,uid,name,grade,year):
        super().__init__(uid,name,'普通员工',grade,year)

    def salary(self):
        #统计并返回工资
        return 3000 + 500 * self.grade + 50 * self.year

#组长
class Teamleader(Staff):
    def __init__(self,uid,name,grade,year):
        super().__init__(uid,name,'组长',grade,year)

    def salary(self):
        #统计并返回工资
        return 4000 + 800 * self.grade + 100 * self.year

#经理
class Manager(Staff):
    def __init__(self,uid,name,grade,year):
        super().__init__(uid,name,'经理',grade,year)

    def salary(self):
        #统计并返回工资
        return 5000 + 1000 * (self.grade + self.year)

#管理类：所有功能的实现
class Manage:
    def __init__(self):
        self.staff = {}
        self.uid = 10000

    def welcome(self):
        #程序功能入口
        ins = 0
        while True:
            ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
            if ins == '1':
                self.typein()
            elif ins == '2':
                self.inquire()
            elif ins == '3':
                self.upgrade()
            elif ins == '4':
                self.degrade()
            elif ins == '5':
                break
            else:
                print('输入错误，请重新输入！')

    def typein(self):
        #录入功能
        name = input('姓名:')
        job = input('职位（E.普通员工;T.组长;M.经理）：')
        year = int(input('工龄：'))
        grade = int(input('级别：'))
        if job == 'E':
            while grade > 10:
                grade = int(input('该职位最高级别为10，请重新录入级别：'))
            self.staff[self.uid] = Employee(self.uid,name,grade,year)
        elif job == 'T':
            while grade > 6:
                grade = int(input('该职位最高级别为6，请重新录入级别：'))
            self.staff[self.uid] = Teamleader(self.uid,name,grade,year)
        elif job == 'M':
            while grade > 3:
                grade = int(input('该职位最高级别为3，请重新录入级别：'))
            self.staff[self.uid] = Manager(self.uid,name,grade,year)
        else:
            print('职位输入错误，请重新输入！')
            return
        
        print(f'录入成功！姓名：{name}, 工号：{self.uid}, 薪资 {self.staff[self.uid].salary()}')
        self.uid += 1

    def inquire(self):
        #查询功能
        num = input('1.员工查询;2.职位查询：')
        
        if num == '1':
            #员工查询
            uid = int(input('请输入工号：'))
            if not self.staff.get(uid):
                print('该工号不存在！')
            else:
                print(f'姓名：{self.staff[uid].name}\n'
                      f'职位：{self.staff[uid].job}\n'
                      f'级别：{self.staff[uid].grade}\n'
                      f'工龄：{self.staff[uid].year}\n'
                      f'薪资：{self.staff[uid].salary()}')

        if num == '2':
            #职位查询
            job_2 = input('职位（E.普通员工;T.组长;M.经理）：')
            job_dict = {'E':'普通员工','T':'组长','M':'经理'}
            job_title = job_dict.get(job_2)
            if not job_title:
                print('职位输入错误，请重新输入！')
                return

            count = sum(1 for staff in self.staff.values() if staff.get_job() == job_title)
            
            if count == 0:
                print(f'目前公司没有{job_title}!')
            else:
                print(f'当前{job_title}共有{count}人：')
                for staff in self.staff.values():
                    if staff.get_job() == job_title:
                        print(f'{staff.get_uid()} - {staff.get_name()}')

    def upgrade(self):
        #升级功能
        uid = int(input('请输入工号：'))
        if not self.staff.get(uid):
            print('该工号不存在！')
            return
        
        staff = self.staff[uid]
        print(f'{staff.get_name()}, 工号：{uid}, 当前职位：{staff.get_job()}{staff.get_grade()}, 当前薪资：{staff.salary()}')
        grade_num = int(input('请输入需要增加的级数：'))
        print('升级成功！')
        old_salary = staff.salary()
        new_grade = staff.get_grade() + grade_num
        
        if staff.get_job() == '普通员工' and new_grade > 10:
            self.staff[uid] = Teamleader(uid,staff.get_name(),1,staff.get_year())
            staff = self.staff[uid]
        elif staff.get_job() == '组长' and new_grade > 6:
            self.staff[uid] = Manager(uid,staff.get_name(),1,staff.get_year())
            staff = self.staff[uid]
        elif staff.get_job() == '经理' and new_grade > 3:
            print('经理职位最高级别为3，无法再升级')
            return
        else:
            staff.grade = new_grade
        change_salary = staff.salary() - old_salary
            
        print(f'{staff.name}, 工号：{uid}, 升级后职位：{staff.job}{staff.grade}, 升级后薪资：{staff.salary()}(+{change_salary})')

    def degrade(self):
        #降级功能
        uid = int(input('请输入工号：'))
        if not self.staff.get(uid):
            print('该工号不存在！')
            return
        
        staff = self.staff[uid]
        print(f'{staff.get_name()}, 工号：{uid}, 当前职位：{staff.get_job()}{staff.get_grade()}, 当前薪资：{staff.salary()}')
        grade_denum = int(input('请输入需要减少的级数：'))
        print('降级成功！')
        old_salary = staff.salary()
        new_grade = staff.get_grade() - grade_denum
        
        if staff.get_job() == '普通员工' and new_grade < 1:
            print('普通员工最低级别为1，不能再降低！')
        elif staff.get_job() == '组长' and new_grade < 1:
            self.staff[uid] = Employee(uid,staff.get_name(),10,staff.get_year())
            staff = self.staff[uid]
        elif staff.get_job() == '经理' and new_grade < 1:
            self.staff[uid] = Teamleader(uid,staff.get_name(),6,staff.get_year())
            staff = self.staff[uid]
        else:
            staff.grade = new_grade
        change_salary = staff.salary() - old_salary
            
        print(f'{staff.name}, 工号：{uid}, 降级后职位：{staff.job}{staff.grade}, 降级后薪资：{staff.salary()}({change_salary})')

def main():
    m = Manage()
    m.welcome()


#程序主体
main()

            

            
        
        
        

lhy12343

# 0. Python 是如何体现面向对象的多态特性的？
# 方法重写：
# 子类继承父类后，可以重写父类的方法。这样，同一个方法在不同的子类中可以有不同的实现。
# 当调用这些方法时，Python会根据对象的实际类型调用相应的方法实现。
#
# 鸭子类型（Duck Typing）：
# Python是一种动态类型语言，不强制要求对象属于某个特定的类型。
# 只要对象实现了所需的方法，就可以作为某个类型来使用。
# 这意味着不同的对象只要实现了相同的方法，就可以互换使用，而不需要继承自同一个父类。
#
# 抽象基类（Abstract Base Classes, ABCs）：
# Python的abc模块允许定义抽象基类，包含抽象方法。子类必须实现这些抽象方法。
# 这样可以确保子类提供特定的方法实现，从而支持多态性。


# 1. 多态的优势是什么？
# 代码重用：
# 多态性允许在不修改现有代码的情况下添加新的功能。
# 通过继承和方法重写，可以创建新的子类，重用已有的父类代码，并对其进行扩展。
#
# 接口统一：
# 多态性提供了一种统一的接口，允许不同类型的对象通过相同的接口进行交互。
# 这使得代码更加简洁和易于理解。调用方无需了解具体的实现细节，只需知道对象具有某些方法即可。
#
# 可扩展性：
# 多态性使得系统更具扩展性。可以方便地添加新的子类和新功能，而无需对现有系统进行大规模修改。
# 这对于维护和扩展软件系统非常有利。
#
# 简化代码逻辑：
# 通过多态性，可以避免复杂的条件语句和类型检查。
# 程序可以更直接地操作对象，调用对象的方法，从而使代码更加清晰和简洁。
#
# 模块化：
# 多态性支持将程序分割成多个独立的模块，每个模块实现某个接口或抽象类的具体功能。
# 这种模块化设计提高了系统的灵活性和可维护性。
#
# 减少耦合：
# 多态性使得不同类之间的耦合度降低。调用方不需要了解对象的具体类型和实现，只需要知道对象具有什么样的方法。
# 这种松耦合设计有助于提高代码的灵活性和可维护性。


# 2. 请问在 Python 中，1+1 == 2 跟 '1' + '1' == '11'，
# 这种根据操作数类型不同，得到不同结果的现象，可以称为多态吗？
# 虽然运算符重载和多态性都涉及到不同类型的处理，但它们关注的重点不同：
# 运算符重载：同一个运算符在不同类型的操作数上有不同的行为。
# 多态性：通过统一的接口处理不同类型的对象，强调动态绑定和方法的多样性。
# 所以，1 + 1 == 2 和 '1' + '1' == '11' 的现象更确切地说是运算符重载，而不是多态。

# 3. 关于鸭子类型这个名字的来源，有一句谚语，你知道是什么吗？
# "If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck."
#
# 这句话的意思是，如果一个对象看起来像鸭子，游起来像鸭子，并且叫起来像鸭子，那么它很可能就是一只鸭子。


# 4. 高内聚低耦合，是判断软件设计好坏的标准。在程序设计中，
# 我们都希望尽可能做到高内聚（内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事，它描述的是模块内的功能联系）
# 和低耦合（耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据）。
# 那么请问，使用鸭子类型，是增强了内聚呢，还是降低了耦合度呢？

# 使用鸭子类型主要是降低了耦合度。它使得代码更加灵活和模块化，模块之间的依赖性降低，从而使得代码更易于维护和扩展。
# 虽然鸭子类型不直接增强内聚性，但通过支持模块的独立性和单一职责，间接促进了高内聚的设计。

# 5. 请问下面代码的执行结果，是属于 Python 的多态现象吗？
# def add(x, y, z=0):
#     return x + y + z
#
#
# print(add(2, 3))
#
# print(add(2, 3, 4))
# 在这段代码中，add函数的行为取决于传递的参数个数，这是通过默认参数实现的，
# 不涉及对象的类型和方法的重写，所以不属于多态现象。
# 它展示的是Python中灵活的函数参数处理机制，而不是多态。

lebeilin

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

smartsy

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：0

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

跳大神er

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：
创造处理不同情况的子类

第 1 题的答案是：
灵活处理更多的类型、情况

第 2 题的答案是：
不，因为这个只是判断bool类型

第 3 题的答案是：
When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.

第 4 题的答案是：
增强了内聚，但是提高了耦合

第 5 题的答案是：
不

-------- 动动手 --------

请将第 0 题的代码写在下方：

1. class Employee:
   
2.     name = None
   
3.     job = None
   
4.     grade = None
   
5.     year = 0
   
6.     uid = None
   
7.     salary = None
   
8.    
   
9.     job_list = ['E', 'T', 'M']
   
10.    
    
11.     def add_new(self, name, job, grade, year, uid):
    
12.         self.name = name
    
13.         self.job = job
    
14.         self.grade = int(grade)
    
15.         self.year = int(year)
    
16.         self.uid = int(uid)
    
17.         self.salary = int(self.salary())
    
18.         
    
19.     def get_uid(self):
    
20.         return self.uid
    
21.    
    
22.     def get_name(self):
    
23.         return self.name
    
24.    
    
25.     def get_job(self):
    
26.         return self.job
    
27.    
    
28.     def get_grade(self):
    
29.         return self.grade
    
30.    
    
31.     def get_year(self):
    
32.         return self.year
    
33.    
    
34.     def salary(self):
    
35.         job = self.get_job()
    
36.         if job == 'E':
    
37.             salary = 3000 + 500 * (self.get_grade()) + 50 * (self.get_year())
    
38.         elif job == 'T':
    
39.             salary = 4000 + 800 * (self.get_grade()) + 100 * (self.get_year())
    
40.         elif job == 'M':
    
41.             salary = 5000 + 1000 * ((self.get_grade()) + (self.get_year()))
    
42.         return salary
    
43.    
    
44.     def get_salary(self, job, grade, year):
    
45.         if job == 'E':
    
46.             salary = 3000 + 500 * grade + 50 * year
    
47.         elif job == 'T':
    
48.             salary = 4000 + 800 * grade + 100 * year
    
49.         elif job == 'M':
    
50.             salary = 5000 + 1000 * (grade + year)
    
51.         return salary
    
52.    
    
53. class EmployeeManageMain(Employee):
    
54.    
    
55.     job_dict = {'E': list(), 'T': list(), 'M': list()}
    
56.     job_grade_dict = {'E' : 10, 'T' : 6, 'M' : 3}
    
57.    
    
58.     employees_dict = {9999 : {'name': 'test_employee0',
    
59.                               'job': 'E',
    
60.                               'grade': 1,
    
61.                               'year': 1,
    
62.                               'uid': 9999,
    
63.                               'salary': 1}
    
64.                              }
    
65.     def __init__(self):
    
66.         while True:  #程序主循环
    
67.             option = input('\n1.录入;2.查询;3.升级;4.降级;5.退出：')
    
68.             if option == '1':
    
69.                 self.add_new_employee()
    
70.             elif option == '2':
    
71.                 self.check()
    
72.             elif option == '3':
    
73.                 self.upgrade()
    
74.             elif option == '4':
    
75.                 self.degrade()
    
76.             elif option == '5':
    
77.                 break
    
78. 
    
79.     def add_new_employee(self):  #功能1.录入
    
80.         name = input('姓名：')
    
81.         while True:
    
82.             job = input('职位（E.普通员工; T.组长; M.经理）：').upper()
    
83.             if job not in Employee().job_list:
    
84.                 print('输入有误，请检查后重新输入！')
    
85.             else:
    
86.                 break
    
87.         while True:
    
88.             grade = int(input('级别：'))
    
89.             if job == 'E' and grade > 10:
    
90.                 print('输入有误，请检查后重新输入！')
    
91.             elif job == 'T' and grade > 6:
    
92.                 print('输入有误，请检查后重新输入！')
    
93.             elif job == 'M' and grade > 3:
    
94.                 print('输入有误，请检查后重新输入！')
    
95.             else:
    
96.                 break
    
97.         year = input('工龄：')
    
98.         uid = sorted(self.employees_dict.keys())[-1] + 1
    
99.         if job == 'E':
    
100.             self.job_dict['E'].append(uid)
     
101.         elif job == 'T':
     
102.             self.job_dict['T'].append(uid)
     
103.         elif job == 'M':
     
104.             self.job_dict['M'].append(uid)
     
105.         
     
106.         new_employee = Employee()
     
107.         new_employee.add_new(name, job, grade, year, uid)
     
108.         salary = new_employee.salary
     
109.         self.employees_dict.update({uid : new_employee.__dict__})
     
110.         print(f'录入成功！ 姓名：{name}, 工号：{uid}, 薪资：{salary}')
     
111.    
     
112.     def check(self):  #功能2.查询
     
113.         check_option = input('1.员工查询; 2.职位查询：')
     
114.         if check_option == '1':   #1.员工查询
     
115.             while True:
     
116.                 uid_checked = int(input('请输入工号：'))
     
117.                 if uid_checked in self.employees_dict.keys():
     
118.                     break
     
119.                 else:
     
120.                     print('该工号不存在，请重新输入！')
     
121.             #将查询到的员工放入员工class类中，以便进行相关运算
     
122.             employee_checked = self.employees_dict[uid_checked]
     
123.             #展示属性
     
124.             print(f"姓名：{employee_checked['name']}\n"+   #使用+分割，避免参数之间有逗号默认的一个小空格
     
125.                   f"职位：{employee_checked['job']}\n"+
     
126.                  f"级别：{employee_checked['grade']}\n"+
     
127.                  f"工龄：{employee_checked['year']}\n"+
     
128.                  f"薪资：{employee_checked['salary']}")
     
129.             
     
130.         elif check_option == '2': #2.职位查询
     
131.             while True:
     
132.                 job = input('职位（E.普通员工; T.组长; M.经理）：').upper()
     
133.                 if job not in Employee().job_list:
     
134.                     print('输入有误，请检查后重新输入！')
     
135.                 else:
     
136.                     job_name = str()
     
137.                     if job == 'E':
     
138.                         job_name = '普通员工'
     
139.                     elif job == 'T':
     
140.                         job_name = '组长'
     
141.                     elif job == 'M':
     
142.                         job_name = '经理'
     
143.                     break        
     
144.             job_list = self.job_dict[job]
     
145.             if len(job_list) > 0:
     
146.                 print(f'目前 {job_name} 共有 {len(job_list)} 人:')
     
147.                 for each in job_list:
     
148.                     check_dict = self.employees_dict[each]
     
149.                     uid = each
     
150.                     name = check_dict['name']
     
151.                     print(f'{uid} - {name}')
     
152.             elif len(job_list) == 0:
     
153.                 print(f'目前公司没有 {job_name} !')
     
154.    
     
155.     def upgrade(self):  #功能3.升级
     
156.         #指定员工（运用工号查询）
     
157.         while True:
     
158.             uid_checked = int(input('请输入工号：'))
     
159.             if uid_checked in self.employees_dict.keys():
     
160.                 break
     
161.             else:
     
162.                 print('该工号不存在，请重新输入！')
     
163.         
     
164.         #将查询到的员工信息在全体员工dict中定位，以便进行相关运算
     
165.         employee_checked = self.employees_dict[uid_checked]
     
166.         
     
167.         #获取属性，并展示
     
168.         name = employee_checked['name']
     
169.         uid = employee_checked['uid']
     
170.         job = employee_checked['job']
     
171.         grade = employee_checked['grade']
     
172.         year = employee_checked['year']
     
173.         current_job_grade = job + str(grade)
     
174.         salary = employee_checked['salary']
     
175.         print(f"{name}, 工号：{uid}, 当前职位：{current_job_grade}, 当前薪资：{salary}")#使用+分割，避免参数之间有逗号默认的一个小空格
     
176.         
     
177.         #按照等级要求，增加等级
     
178.         job_list = list(self.job_grade_dict.keys())
     
179.         upgrade_input = int(input('请输入需要增加的级数：'))
     
180.         after_grade = grade + upgrade_input
     
181.         if after_grade <= self.job_grade_dict[job]:
     
182.             employee_checked['grade'] = after_grade
     
183.         elif after_grade > self.job_grade_dict[job]:  #当升级后级数超过当前职位的最高级数
     
184.             if job != job_list[-1]:
     
185.                 while True:
     
186.                     after_grade = after_grade - self.job_grade_dict[job]
     
187.                     job = job_list[job_list.index(job) + 1]
     
188.                     if after_grade > self.job_grade_dict[job]:
     
189.                         if job == job_list[-1]:
     
190.                             return print('升级后的职位超出最大限制，请检查后重新输入！')
     
191.                         else:
     
192.                             continue
     
193.                     else:
     
194.                         break
     
195.             else:
     
196.                 return print('升级后的职位超出最大限制，请检查后重新输入！')
     
197.         
     
198.         #写入属性
     
199.         grade = after_grade
     
200.         employee_checked['grade'] = after_grade
     
201.         employee_checked['job'] = job
     
202.         
     
203.         current_job_grade = job + str(grade)
     
204.                              
     
205.         after_salary = self.get_salary(job, grade, year)
     
206.         salary_difference = after_salary - salary
     
207.         if salary_difference > 0:
     
208.             salary_difference = '+' + str(salary_difference)
     
209.         salary = after_salary
     
210.         employee_checked['salary'] = salary
     
211.         
     
212.         print('升级成功！')
     
213.         print(f'{name}, 工号：{uid}, 升级后职位：{current_job_grade}, 升级后薪资：{salary} ({salary_difference})')
     
214.         
     
215.     def degrade(self):  #功能4.降级
     
216.         #指定员工（运用工号查询）
     
217.         while True:
     
218.             uid_checked = int(input('请输入工号：'))
     
219.             if uid_checked in self.employees_dict.keys():
     
220.                 break
     
221.             else:
     
222.                 print('该工号不存在，请重新输入！')
     
223.         
     
224.         #将查询到的员工信息在全体员工dict中定位，以便进行相关运算
     
225.         employee_checked = self.employees_dict[uid_checked]
     
226.         
     
227.         #获取属性，并展示
     
228.         name = employee_checked['name']
     
229.         uid = employee_checked['uid']
     
230.         job = employee_checked['job']
     
231.         grade = employee_checked['grade']
     
232.         year = employee_checked['year']
     
233.         current_job_grade = job + str(grade)
     
234.         salary = employee_checked['salary']
     
235.         print(f"{name}, 工号：{uid}, 当前职位：{current_job_grade}, 当前薪资：{salary}")#使用+分割，避免参数之间有逗号默认的一个小空格
     
236.         
     
237.         #按照等级要求，减少等级
     
238.         job_list = list(self.job_grade_dict.keys())
     
239.         upgrade_input = int(input('请输入需要减少的级数：'))
     
240.         after_grade = grade - upgrade_input
     
241.         if after_grade >= 1:
     
242.             employee_checked['grade'] = after_grade
     
243.         elif after_grade < 1:  #当降级后级数低过当前职位的最低级数（0或负数）
     
244.             if job != job_list[0]:
     
245.                 while True:
     
246.                     job = job_list[job_list.index(job) - 1]  #降低一级职位
     
247.                     after_grade = self.job_grade_dict[job] + after_grade  #因为after_grade是0或负数，所以用加法
     
248.                     
     
249.                     if after_grade < 1:
     
250.                         if job == job_list[0]:
     
251.                             return print('降级后的职位超出最低限制，请检查后重新输入！')
     
252.                         else:
     
253.                             continue
     
254.                     else:
     
255.                         break
     
256.             else:
     
257.                 return print('降级后的职位超出最低限制，请检查后重新输入！')
     
258.         
     
259.         #写入属性
     
260.         grade = after_grade
     
261.         employee_checked['grade'] = after_grade
     
262.         employee_checked['job'] = job
     
263.         
     
264.         current_job_grade = job + str(grade)
     
265.                              
     
266.         after_salary = self.get_salary(job, grade, year)
     
267.         salary_difference = after_salary - salary
     
268.         if salary_difference > 0:
     
269.             salary_difference = '+' + str(salary_difference)
     
270.         salary = after_salary
     
271.         employee_checked['salary'] = salary
     
272.         
     
273.         print('升级成功！')
     
274.         print(f'{name}, 工号：{uid}, 降级后职位：{current_job_grade}, 降级后薪资：{salary} ({salary_difference})')
     
275. 
     
276.         
     
277. main = EmployeeManageMain()

复制代码

GeraldKingyoung

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：
import pathlib
import pickle
if not pathlib.Path(r"C:\Users\Administrator\Desktop\baocun.txt").exists():
    Max = {'E':['普通员工',10,1],'T':['组长',6,2],'M':['经理',3,3]}
    jobnum = 999
    name = []
    position = []
    age =[]
    jobNum = []
    level =[]
    with open(r"C:\Users\Administrator\Desktop\baocun.txt",'wb') as f:
            pickle.dump(Max,f)
            pickle.dump(jobnum,f)
            pickle.dump(name,f)
            pickle.dump(position,f)
            pickle.dump(age,f)
            pickle.dump(jobNum,f)
            pickle.dump(level,f)
else:
    with open(r"C:\Users\Administrator\Desktop\baocun.txt",'rb') as f:
        Max=pickle.load(f)
        jobnum=pickle.load(f)
        name=pickle.load(f)
        position=pickle.load(f)
        age=pickle.load(f)
        jobNum=pickle.load(f)
        level=pickle.load(f)

   
class Employee:
    global name
    global position
    global age
    global jobNum
    global level
    def writein(self):
        self.name = input('姓名：')
        name.append(self.name)
        self.position = input('职位（E.普通员工；T.组长；M.经理）:')
        position.append(self.position)
        self.age = int(input('工龄：'))
        age.append(self.age)
        self.level = int(input('级别：'))
        while self.level > Max.get(self.position)[1]:
            self.level = int(input(f'该职位最高级别为{Max.get(self.position)[1]}，请重新录入级别：'))
        level.append(self.level)
               
        global jobnum
        jobnum += 1
        jobNum.append(jobnum)
        
        print(f'录入成功！姓名：{self.name}；工号：{jobnum}； 薪资：{self.salarycount(self.position,self.level,self.age)}')
        
    def salarycount(self,position,level,age):
        if position == 'E':
            self.salary = 3000+500*level+50*age
        elif position == 'T':
            self.salary = 4000+800*level+100*age
        elif position =='M':
            self.salary = 5000+1000*(level+age)
        return self.salary

    def inquire(self):
        quirenum = int(input('1.工号查询；2.职位查询'))
        jishu = 0
        if quirenum == 1:
            quirejobnum = int(input('请输入工号：'))
            for i in jobNum:
                if i == quirejobnum:
                    _=jobNum.index(quirejobnum)
                    print(f'姓名：{name[_]}，职位：{position[_]}，级别：{level[_]}，工龄：{age[_]}，薪资：{self.salarycount(position[_],level[_],age[_])}')
                    jishu += 1

        elif quirenum == 2:
            quireposition = input('请输入职位（E.普通员工；T.组长；M.经理）：')
            print(f'目前{Max.get(quireposition)[0]}共有{len([p for p in position if p == quireposition])}人：')
            for j in position:
                if j == quireposition:
                    __=position.index(quireposition)
                    print(f'{jobNum[__]} - {name[__]}')        
                    jishu += 1

        if jishu == 0:
            print('查询条件不存在！')

    def levelchange(self):
        changenum = int(input('请输入工号：'))
        if changenum in jobNum:
            ___=jobNum.index(changenum)
            print(f'姓名：{name[___]}，工号：{jobNum[___]}，当前职位：{position[___]}{level[___]}，当前薪资：{self.salarycount(position[___],level[___],age[___])}')
            jishu += 1
            changenum = int(input('请输入改变的级数：'))
            level[___] += changenum
            
            while level[___] > Max.get(position[___])[1]:
                level[___] = level[___] - Max.get(position[___])[1]
                p = Max.get(position[___])[2] + 1
                for key,value in Max.items():
                    if p == value[2]:
                        position[___] = key

            while level[___] < 1:
                p = Max.get(position[___])[2] - 1
                for key,value in Max.items():
                    if p == value[2]:
                        position[___] = key
                level[___] = level[___] + Max.get(position[___])[1]
               
               
               
            print('职级变动成功！')
            print(f'姓名：{name[___]}，工号：{jobNum[___]}，调整后职位：{position[___]}{level[___]}，调整后薪资：{self.salarycount(position[___],level[___],age[___])}')
               
        else:
            print('查询条件不存在！')



def main():
    num = int(input('1.录入；2.查询；3.职位变动；4.退出'))
    while num != 4:
        if num == 1:
            a = Employee()
            a.writein()
            
        if num == 2:
            b = Employee()
            b.inquire()

        if num == 3:
            c = Employee()
            c.levelchange()
            
        num = int(input('1.录入；2.查询；3.职位变动；4.退出'))

    else:
        with open(r"C:\Users\Administrator\Desktop\baocun.txt",'wb') as f:
            pickle.dump(Max,f)
            pickle.dump(jobnum,f)
            pickle.dump(name,f)
            pickle.dump(position,f)
            pickle.dump(age,f)
            pickle.dump(jobNum,f)
            pickle.dump(level,f)

GeraldKingyoung

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：不同对象的属性反馈不同

第 1 题的答案是：一函数多用

第 2 题的答案是：可以

第 3 题的答案是：捉到耗子就是好猫

第 4 题的答案是：都不是

第 5 题的答案是：不属于

-------- 动动手 --------

请将第 0 题的代码写在下方：

sin0824

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：在每个类中调用同一个种方法，返回不同的值

第 1 题的答案是：灵活性，代码维护性强

第 2 题的答案是：可以

第 3 题的答案是：一只鹅比任何鸭子都要聪明。

第 4 题的答案是：低耦合  鸭子类型体现在接口的宽容度上（我们不需要关心对象具体是什么类型，只在乎它的行为方法是否符合要求即可）

第 5 题的答案是：不属于多态

-------- 动动手 --------

请将第 0 题的代码写在下方：

阿碧的老司机

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

七刀会

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：可以

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：不是

-------- 动动手 --------

请将第 0 题的代码写在下方：
class People:
    def __init__(self,name,job,grade,year,salary):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
        self.salary = salary
class Manage():
    def __init__(self):
        self.members = {}
        self.uid = 10000
    def welcome(self):#主程序
        ins = 0
        while ins != '5':
            ins = input("1.录入;2.查询;3.升级;4.降级;5.退出:")
            if ins == '1':
                self.creat_member()
            if ins == '2':
                inst = input("1.员工查询;2.职位查询:")
                if inst == '1':
                    self.query_member()
                elif inst == '2':
                    self.seach_member()
            if ins == '3':
                self.up_member()
            if ins == '4':
                self.down_member()
            if ins == '5':
                break
    def creat_member(self):#录入
        name = input("姓名：")
        salary = 0
        select = input("职位(E.普通员工；T.组长；M.经理)：")
        year = int(input("工龄："))
        #grade = int(input("级别："))
        grade = self.confirm_grade(select)
        if select == 'E':
            #sa = Employee()
            #salary = sa.salary(grade,year)
            salary = 3000 + 500 * grade + 50 * year
            #self.job = '普通员工'
            job = '普通员工'
        elif select == 'T':
            #sa = Teamleader()
            #salary = sa.salary(grade,year)
            salary = 4000 + 800 * grade + 100 * year
            #self.job = '组长'
            job = '组长'
        elif select == 'M':
            #sa = Manager()
            #salary = sa.salary(grade,year)
            salary = 5000 + 1000 * (grade + year)
            #self.job = '经理'            
            job = '经理'
        people = People(name,job,grade,year,salary)
        self.members[self.uid] = people
        
        print(f"录入成功！姓名：{self.members[self.uid].name},工号：{self.uid},薪资：{self.members[self.uid].salary}")
        self.uid += 1
    def confirm_grade(self,select):#验证级别是否超过限度
        sa = int(input("级别："))
        if select == 'E':
            while sa > 10:
                sa = int(input("该职位最高级别为10,请重新录入级别："))
        elif select == 'T':
            while sa > 6:
                sa = int(input("该职位最高级别为6,请重新录入级别："))
        elif select == 'M':
            while sa > 3:
                sa = int(input("该职位最高级别为3,请重新录入级别："))
        return sa
    def query_member(self):#员工查询
        number = int(input("请输入工号:"))
        if not self.members.get(number):
                print("该工号不存在！")
        else:
            print(f'姓名:{self.members[number].name}')
            print(f'职位:{self.members[number].job}')
            print(f'级别:{self.members[number].grade}')
            print(f'工龄:{self.members[number].year}')
            print(f'薪资:{self.members[number].salary}')
    def seach_member(self):#职位查询
        j = input("职位(E.普通员工；T.组长；M.经理)：")
        if j == 'E':
            b = '普通员工'
        elif j == 'T':
            b = '组长'
        elif j == 'M':
            b = '经理'
        a = 0
        for num in self.members:
            if b == self.members[num].job:
                a += 1
        if a != 0:
            print(f'目前{b}共有{a}人')
        else:
            print(f'目前公司没有{b}')
    def up_member(self):#升职 注意跨级
        inst = int(input("请输入工号:"))
        if not self.members.get(inst):
                print("该工号不存在！")
        else:
            if self.members[inst].job == '普通员工':
                j = 'E'
                limit = 10
            elif self.members[inst].job == '组长':
                j = 'T'
                limit = 6
            elif self.members[inst].job == '经理':
                j = 'M'
                limit = 3
            k = self.members[inst].grade
            pp = self.members[inst].salary
            print(f'{self.members[inst].name},工号：{inst},当前职位：',end = '')
            print(f',{j + str(k)}',end = '')
            print(f',当前薪资{pp}')
        ud = int(input("请输入需要增加的级数："))
        k = k + ud
        if k > limit:
            k = k - limit
            self.members[inst].grade = k
            if j =='E':
                j ='T'
                self.members[inst].job = '组长'
                self.members[inst].salary = 4000 + 800 * k + 100 * self.members[inst].year
            elif j == 'T':
                j = 'M'
                self.members[inst].job = '经理'
                self.members[inst].salary = 5000 + 1000 * (k + self.members[inst].year)
            elif j == 'M':
                print('no')
        else:
            self.members[inst].grade = k
            if j =='E':
                self.members[inst].salary = 3000 + 500 * k + 50 * self.members[inst].year
            elif j == 'T':
                self.members[inst].salary = 5000 + 1000 * (k + self.members[inst].year)
            elif j == 'M':
                self.members[inst].salary = 5000 + 1000 * (k + self.members[inst].year)
        print("升级成功！")
        print(f'{self.members[inst].name},工号：{inst},当前职位：',end = '')
        print(f',{j + str(k)}',end = '')
        print(f',升级后薪资{self.members[inst].salary}',end = '')
        print(f'(+{self.members[inst].salary - pp})')
        
    def down_member(self):#降职
        inst = int(input("请输入工号:"))
        if not self.members.get(inst):
                print("该工号不存在！")
        else:
            if self.members[inst].job == '普通员工':
                j = 'E'
            elif self.members[inst].job == '组长':
                j = 'T'
                limit = 10
            elif self.members[inst].job == '经理':
                j = 'M'
                limit = 6
            k = self.members[inst].grade
            pp = self.members[inst].salary
            print(f'{self.members[inst].name},工号：{inst},当前职位：',end = '')
            print(f',{j + str(k)}',end = '')
            print(f',当前薪资{pp}')
        ud = int(input("请输入需要减少的级数："))
        k = k - ud
        if k < 1:
            k = k + limit
            self.members[inst].grade = k
            if j =='M':
                j ='T'
                self.members[inst].job = '组长'
                self.members[inst].salary = 4000 + 800 * k + 100 * self.members[inst].year
            elif j == 'T':
                j = 'E'
                self.members[inst].job = '普通员工'
                self.members[inst].salary = 3000 + 500 * k + 50 * self.members[inst].year
            elif j == 'E':
                print('no')
        else:
            self.members[inst].grade = k
            if j =='E':
                self.members[inst].salary = 3000 + 500 * k + 50 * self.members[inst].year
            elif j == 'T':
                self.members[inst].salary = 5000 + 1000 * (k + self.members[inst].year)
            elif j == 'M':
                self.members[inst].salary = 5000 + 1000 * (k + self.members[inst].year)
        print("降级成功！")
        print(f'{self.members[inst].name},工号：{inst},当前职位：',end = '')
        print(f',{j + str(k)}',end = '')
        print(f',降级后薪资{self.members[inst].salary}',end = '')
        print(f'({self.members[inst].salary - pp})')  
        
def main():
    m = Manage()
    m.welcome()

檬蒗蒗

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

数声蜀魄入帘栊

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：在子类中直接对父类中要修改的方法进行修改，实现同一个方法不同作用

第 1 题的答案是：对父类中不满意的方法可以直接在子类中修改

第 2 题的答案是：不可以

第 3 题的答案是：

第 4 题的答案是：高内聚

第 5 题的答案是：不是

-------- 动动手 --------

请将第 0 题的代码写在下方：
class Member:
     def __init__(self,name,zhiwei,age,jibie,pay):
          self.name=name
          self.zhiwei=zhiwei
          self.age=age
          self.jibie=jibie
          self.pay=pay
class Manage:
     def __init__(self):
          self.member={}
          self.card=10000
     def a(self):
          b=input('\n1.录入;2.查询;3.升级;4.降级;5.退出:')
          if b=='1':
               self.creat()
          if b=='2':
               self.seek()
          if b=='3':
               self.shengji()
          if b=='4':
               self.jiangji()
          if b=='5':
               return
     def p(self,zhiwei,jibie,age):
          if zhiwei=='M':
               while jibie>3:
                    jibie=int(input('该职位最高级别为3，请重新录入级别：'))
               pay=5000+1000*(jibie+age)
          if zhiwei=='T':
               while jibie>6:
                    jibie=int(input('该职位最高级别为6，请重新录入级别：'))
               pay=4000+800*jibie+age*100
          if zhiwei=='E':
               while jibie>10:
                    jibie=int(input('该职位最高级别为10，请重新录入级别：'))
               pay=3000+500*jibie+50*age
          return pay,jibie
     def creat(self):
          name=input('姓名：')
          zhiwei=input('职位（E.普通员工;T.组长;M.经理）：')
          age=int(input('工龄：'))
          jibie=int(input('级别：'))
          pay,jibie=self.p(zhiwei,jibie,age)[0],self.p(zhiwei,jibie,age)[1]
          member=Member(name,zhiwei,age,jibie,pay)
          self.member[self.card]=member
          print(f'录入成功！姓名：{self.member[self.card].name},工号：{self.card},薪资：{self.member[self.card].pay}')
          self.card+=1
          self.a()
     def seek(self):
          b=input('1.员工查询；2.职位查询：')
          if b=='1':
               c=int(input('请输入工号：'))
               if c in self.member:
                    print(f'姓名：{self.member[c].name}')
                    print(f'职位：{self.member[c].zhiwei}')
                    print(f'级别：{self.member[c].jibie}')
                    print(f'工龄：{self.member[c].age}')
                    print(f'薪资：{self.member[c].pay}')
                    self.a()
               else:
                    print('该工号不存在！')
                    self.a()
          if b=='2':
               c=input('职位（E.普通员工;T.组长;M.经理）：')
               t={'E':'普通员工','T':'组长','M':'经理'}
               n=0
               x=[]
               for i in self.member:
                    if self.member[i].zhiwei==c:
                         n+=1
                         x.append(i)
               print(f'目前{t[c]}共有{n}人：')
               for j in x:
                    print( f'{j}-{self.member[j].name}')
     def shengji(self):
          c=int(input('请输入工号：'))
          print(f'{self.member[c].name},工号：{c},当前职位：{self.member[c].zhiwei}{self.member[c].jibie},当前薪资：{self.member[c].pay}')
          d=int(input('请输入需要增加的级数：'))
          print('升级成功！')
          print(f'{self.member[c].name},工号：{c},当前职位：{self.member[c].zhiwei}{self.member[c].jibie},当前薪资：{self.member[c].pay}')
     def jiangji(self):
          pass   
def main():
     m=Manage()
     m.a()

dot_35

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：