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

brav

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

请回复您的答案^_^

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

第 0 题的答案是：
只需要对象的方法符合要求，就可以调用
第 1 题的答案是：
使代码更加模块化、易于扩展和维护。
第 2 题的答案是：
可以
第 3 题的答案是：
“如果它走起来像鸭子，叫起来也像鸭子，那么它很可能就是一只鸭子。”
    这句话强调的是行为和接口的重要性，而不是对象的具体类型。
第 4 题的答案是：
鸭子类型增强了低耦合度：通过关注对象的行为而非具体类型，
    鸭子类型减少了模块之间的硬编码依赖，提高了系统的灵活性和可维护性。
    鸭子类型不直接影响内聚性：内聚性主要关注模块内的功能联系，鸭子类
    型更多地帮助实现低耦合，但需要结合良好的设计来实现高内聚。
第 5 题的答案是：
是
-------- 动动手 --------

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

一只co

1

tutu_zhang

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

zkw1225

请回复您的答案^_^

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

第 0 题的答案是：
具有同样名字的方法，可以有不同的作用
第 1 题的答案是：
同样方法不同作用
第 2 题的答案是：
可以
第 3 题的答案是：
bzd
第 4 题的答案是：
低耦合
第 5 题的答案是：
不是
-------- 动动手 --------

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

liujg01

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

是条咸鱼

请回复您的答案^_^

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

第 0 题的答案是：​​继承与方法重写​​：子类覆盖父类方法。
​​鸭子类型​​：不依赖继承，只依赖对象的行为。
​​运算符重载​​：通过特殊方法自定义运算符行为。
​​抽象基类​​：强制子类实现统一接口。
​​动态类型系统​​：函数参数和变量无需声明类型，运行时确定行为。

第 1 题的答案是：提高代码的灵活性和可扩展性​
减少代码重复（DRY 原则）
第 2 题的答案是：可以

第 3 题的答案是：If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.

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

第 5 题的答案是：这个例子体现的是 ​​函数参数默认值（Default Arguments）​​ 和 ​​函数重载（Function Overloading）的模拟​​，而不是多态（Polymorphism）。



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

请将第 0 题的代码写在下方：class Employee:
    def __init__(self, name, grade, year, uid):
        self.name = name
        self.grade = grade
        self.year = year
        self.uid = uid

    def salary(self):
        return 3000 + 500 * self.grade + 50 * self.year


class TeamLeader(Employee):
    def salary(self):  #
        return 4000 + 800 * self.grade + 100 * self.year


class Manager(Employee):
    def salary(self):
        return 5000 + 1000 * (self.grade + self.year)

python渣渣顺

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

Derekghost

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

Start_learning

请回复您的答案^_^

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

第 0 题的答案是：
继承和方法重写，鸭子类型
第 1 题的答案是：
一个接口面对不同对象
第 2 题的答案是：
可以，+号和==号都多态
第 3 题的答案是：

第 4 题的答案是：
增强了
第 5 题的答案是：

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

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

夏目。。

请回复您的答案^_^

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

第 0 题的答案是：
不同对象传入同一个类中调用各自不同的方法
第 1 题的答案是：
减少代码冗余
第 2 题的答案是：
不能,从结果来看,两者没有任何关系
第 3 题的答案是：
不知道
第 4 题的答案是：
降低耦合
第 5 题的答案是：
是的
-------- 动动手 --------

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

gainer

请回复您的答案^_^

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

第 0 题的答案是：
方法重写（Override）、鸭子类型（Duck Typing）
第 1 题的答案是：
多态的优势是代码复用率高，可读性强，结构清晰
第 2 题的答案是：
从广义多态的角度来看是符合多态概念，符合多态 “一个接口，多种实现” 的本质特征，
但更多地体现了 Python 中运算符重载这一特性
第 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 题的代码写在下方：
# 初始化会员字典
members = {}

# 定义 job 字典
job_dict = {
    "E": "普通员工",
    "T": "组长",
    "M": "经理"
}

# 定义每个职位的最高级别
job_max_grade = {
    "E": 10,
    "T": 6,
    "M": 3
}

# 定义职位顺序
job_order = ["E", "T", "M"]

class Members:
    def __init__(self, name, job, grade, year, uid):
        self.name = name
        valid_job = job_order  # job_order 是 ["E", "T", "M"]
        if job in valid_job:
            self.job = job
        else:
            raise ValueError(f"职位必须是 {valid_job} 中的一个。")  # 直接使用列表
        
        # 获取当前职位的最高级别
        current_max_grade = job_max_grade[job]  # 通过字典键访问值
        
        if job == "E":
            if 1 <= grade <= current_max_grade:
                self.grade = grade
            else:
                raise ValueError(f"当职位为 'E' 时，级别必须在 1 到 {current_max_grade} 之间。")
        elif job == "T":
            if 1 <= grade <= current_max_grade:
                self.grade = grade
            else:
                raise ValueError(f"当职位为 'T' 时，级别必须在 1 到 {current_max_grade} 之间。")
        elif job == "M":
            if 1 <= grade <= current_max_grade:
                self.grade = grade
            else:
                raise ValueError(f"当职位为 'M' 时，级别必须在 1 到 {current_max_grade} 之间。")
        self.year = year
        self.uid = uid
    def get_uid(self, uid):
        if uid in members:
            member = members[uid]
            salary = member.get_salary(member.job, member.grade, member.year)
            return f'姓名：{member.name}\n职位：{member.job}\n级别：{member.grade}\n工龄：{member.year}\n薪资：{salary}\n'
        else:
            return '该工号不存在'
    def get_name(self):
        return (self.name)
    def get_job(self):
        return (self.job)
    def get_grade():
        return (self.grade)
    def get_year(self):
        return (self.year)
    def get_salary(self, job, grade, year):
        if job == 'E':
            j = 3000
            l = 500
            y =50
        elif job == 'T':
            j = 4000
            l = 800
            y =100
        elif job == 'M':
            j = 5000
            l = 1000
            y = 1000
        return( j + l *grade + y * year)
    def upgrade(self, upgrade):
        old_salary = self.get_salary(self.job, self.grade, self.year)
        new_grade = self.grade + upgrade
        current_job_index = job_order.index(self.job)
        while new_grade > job_max_grade[self.job]:
            if current_job_index < len(job_order) - 1:
                current_job_index += 1
                self.job = job_order[current_job_index]
                new_grade = 1  # 升为上一职位的最低级
            else:
                new_grade = job_max_grade[self.job]
                break
        self.grade = new_grade
        salary = self.get_salary(self.job, self.grade, self.year)
        print(f'升级成功！\n{self.name}，工号：{self.uid}；升级后职位：{self.job}{self.grade}；升级后薪资：{salary}(+{salary - old_salary})')

    def downgrade(self, downgrade):
        old_salary = self.get_salary(self.job, self.grade, self.year)
        new_grade = self.grade - downgrade
        current_job_index = job_order.index(self.job)
        while new_grade < 1:
            if current_job_index > 0:
                current_job_index -= 1
                self.job = job_order[current_job_index]
                new_grade = job_max_grade[self.job]  # 降为下一职位的最高级
            else:
                new_grade = 1
                break
        self.grade = new_grade
        salary = self.get_salary(self.job, self.grade, self.year)
        print(f'降级成功！\n{self.name}，工号：{self.uid}；降级后职位：{self.job}{self.grade}；降级后薪资：{salary}({salary - old_salary})')


class Manage:
    def __init__(self):
        # 这里原代码中 member = Members() 没有意义，因为没传参数会报错，可注释或删除
        # member = Members()
        pass
    def get_valid_job(self):
        while True:
            job = input("职位（E.普通员工：T.组长：M.经理）：")
            if job.upper() in ("E", "T", "M"):
                job = job.upper()
                max_grade = 10 if job == "E" else 6 if job == "T" else 3
                return job, max_grade
            job = input("职位只能是 E.普通员工、T.组长或 M.经理。请重新录入职位：")
            if job.upper() in ("E", "T", "M"):
                job = job.upper()
                max_grade = 10 if job == "E" else 6 if job == "T" else 3
                return job, max_grade

    def get_valid_grade(self, job, max_grade):
        while True:
            try:
                grade = int(input("级别："))
                if (job == "E" and 1 <= grade <= 10) or (job == "T" and 1 <= grade <= 6) or (job == "M" and 1 <= grade <= 3):
                    return grade
                grade = input(f"该职位最高级别为：{max_grade}，请重新录入级别：")
                grade = int(grade)
                if (job == "E" and 1 <= grade <= 10) or (job == "T" and 1 <= grade <= 6) or (job == "M" and 1 <= grade <= 3):
                    return grade
            except ValueError:
                grade = input(f"输入错误: 级别必须是整数，该职位最高级别为：{max_grade}，请重新录入级别：")
                try:
                    grade = int(grade)
                    if (job == "E" and 1 <= grade <= 10) or (job == "T" and 1 <= grade <= 6) or (job == "M" and 1 <= grade <= 3):
                        return grade
                except ValueError:
                    continue
               
    def run(self):
        while True:
            try:
                c = int(input("1.录入：2.查询：3.升级：4.降级：5.退出："))
                if c == 1:
                    name = input("姓名：")
                    job, max_grade = self.get_valid_job()
                    year = int(input("工龄："))
                    grade = self.get_valid_grade(job, max_grade)
                    if not members:
                        uid = 10000
                    else:
                        uid = max(int(m) for m in members.keys()) + 1
                    member = Members(name, job, grade, year, uid)
                    members[uid] = member
                    salary = member.get_salary(job, grade, year)
                    print(f"录入成功! 姓名：{name}，工号：{uid}，薪资：{salary}")
               
                elif c == 2:
                    c2 = input("1.员工查询，2.职位查询：")
                    if c2 == "1":
                        c2_uid = int(input("请输入工号："))
                        if c2_uid in members:
                            member = members[c2_uid]
                            print(member.get_uid(c2_uid))
                        else:
                            print('该工号不存在')
                    elif c2 == "2":
                        c2_job, _ = self.get_valid_job()
                        job_title = job_dict[c2_job]
                        job_members = [member for uid, member in members.items() if member.job == c2_job]
                        if len(job_members) == 0:
                            print(f'目前公司没有{job_title}！')
                        else:
                            print(f"目前{job_title}的人数是{len(job_members)}")
                        for member in job_members:
                            print(f"{member.uid} - {member.name}")
                    else:
                        print('无效的选项，请输入1 或 2 。')
                elif c == 3:
                    c3_uid = int(input('请输入工号：'))
                    while c3_uid not in members:
                        print('该工号不存在，请重新输入！')
                        c3_uid = int(input('请输入工号：'))
                    member = members[c3_uid]
                    up_g = int(input(f"{member.name}，工号：{member.uid}；当前职位：{member.job}{member.grade}；当前薪资：{member.get_salary(member.job, member.grade, member.year)}\n请输入需要增加的级数："))
                    member.upgrade(up_g)

                elif c == 4:
                    c4_uid = int(input('请输入工号：'))
                    while c4_uid not in members:
                        print('该工号不存在，请重新输入！')
                        c4_uid = int(input('请输入工号：'))
                    member = members[c4_uid]
                    d_g = int(input(f"{member.name}，工号：{member.uid}；当前职位：{member.job}{member.grade}；当前薪资：{member.get_salary(member.job, member.grade, member.year)}\n请输入需要减少的级数："))
                    member.downgrade(d_g)
                                         
                elif c == 5:
                            break
            except ValueError as e:
                print(f"输入错误: {e}")
            except KeyError:
                print("工号不存在，请重新输入。")
               
def main():
    manage = Manage()
    manage.run()

if __name__ == "__main__":
    main()

songyongkun

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

ZPi

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

第 0 题的答案是：
通过同一函数名操作不同类

第 1 题的答案是：
减少代码量

第 2 题的答案是：
不能

第 3 题的答案是：
If it walks like a duck and quacks like a duck, then it must be a duck.

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

第 5 题的答案是：
不属于

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

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

1. def create_uid():
   
2.     uid = 9999
   
3. 
   
4.     def inner() -> int:
   
5.         nonlocal uid
   
6.         uid += 1
   
7.         return uid
   
8. 
   
9.     return inner
   
10. 
    
11. 
    
12. ct_uid = create_uid()
    
13. 
    
14. 
    
15. class Worker:
    
16.     def __init__(self, name: str, job: str, grade: int, year: int) -> None:
    
17.         self.name = name
    
18.         self.job = job
    
19.         self.grade = grade
    
20.         self.year = year
    
21.         self.uid = ct_uid()
    
22. 
    
23.     def get_uid(self):
    
24.         print(f"工号：{self.uid}")
    
25. 
    
26.     def get_name(self):
    
27.         print(f"姓名：{self.name}")
    
28. 
    
29.     def get_job(self):
    
30.         print(f"职位：{self.job}")
    
31. 
    
32.     def get_grade(self):
    
33.         print(f"级别：{self.grade}")
    
34. 
    
35.     def get_year(self):
    
36.         print(f"工龄：{self.year}")
    
37. 
    
38. 
    
39. class GetSalaryMixin:
    
40.     def get_salary(self):
    
41.         print(f"薪资：{self.salary()}")
    
42. 
    
43. 
    
44. class ChangeGradeMixin:
    
45.     def cgrade(self, rank: int) -> bool:
    
46.         self.grade += rank
    
47.         if self.grade < 1:
    
48.             self.grade = 1
    
49.         elif self.grade > self.max_grade:
    
50.             self.grade = self.max_grade
    
51.         return True
    
52. 
    
53. 
    
54. class Employee(ChangeGradeMixin, GetSalaryMixin, Worker):
    
55.     max_grade = 10
    
56. 
    
57.     def __init__(self, name: str, grade: int, year: int) -> None:
    
58.         super().__init__(name, "E", grade, year)
    
59. 
    
60.     def salary(self):
    
61.         return 3000 + 500 * self.grade + 50 * self.year
    
62. 
    
63. 
    
64. class Teamleader(ChangeGradeMixin, GetSalaryMixin, Worker):
    
65.     max_grade = 6
    
66. 
    
67.     def __init__(self, name: str, grade: int, year: int) -> None:
    
68.         super().__init__(name, "T", grade, year)
    
69. 
    
70.     def salary(self):
    
71.         return 4000 + 800 * self.grade + 100 * self.year
    
72. 
    
73. 
    
74. class Manager(ChangeGradeMixin, GetSalaryMixin, Worker):
    
75.     max_grade = 3
    
76. 
    
77.     def __init__(self, name: str, grade: int, year: int) -> None:
    
78.         super().__init__(name, "M", grade, year)
    
79. 
    
80.     def salary(self):
    
81.         return 5000 + 1000 * (self.grade + self.year)
    
82. 
    
83. 
    
84. class Manage:
    
85.     workers: list[Employee, Teamleader, Manager] = []
    
86.     occupation_pool: dict[str, list[Employee | Teamleader | Manager]] = {
    
87.         "E": [],
    
88.         "T": [],
    
89.         "M": [],
    
90.     }
    
91. 
    
92.     def input_plus_int(self, s: str) -> int:
    
93.         while True:
    
94.             try:
    
95.                 num = int(input(s))
    
96.                 if num < 0:
    
97.                     raise ValueError
    
98.                 return num
    
99.             except ValueError:
    
100.                 print("请用正整数输入！")
     
101.             except KeyboardInterrupt:
     
102.                 print("\n操作被用户中断")
     
103.                 raise
     
104. 
     
105.     def findWorker(self) -> tuple[int, Employee | Teamleader | Manager]:
     
106.         uid = self.input_plus_int("请输入工号：")
     
107.         for i, worker in enumerate(self.workers):
     
108.             if worker.uid == uid:
     
109.                 return i, worker
     
110.         else:
     
111.             print("该工号不存在！")
     
112.             return -1, worker
     
113. 
     
114.     def enroll(self) -> None:
     
115.         name = input("姓名：")
     
116.         job = input("职位（E.普通员工；T.组长；M.经理）：")
     
117.         year = self.input_plus_int("工龄：")
     
118.         grade = self.input_plus_int("级别：")
     
119.         if job == "E":
     
120.             while grade > Employee.max_grade:
     
121.                 grade = self.input_plus_int(
     
122.                     f"该职位最高级别为{Employee.max_grade}，请重新录入级别："
     
123.                 )
     
124.             temp = Employee(name, grade, year)
     
125.             self.workers.append(temp)
     
126.             self.occupation_pool[job].append(temp)
     
127.         elif job == "T":
     
128.             while grade > Teamleader.max_grade:
     
129.                 grade = self.input_plus_int(
     
130.                     f"该职位最高级别为{Teamleader.max_grade}，请重新录入级别："
     
131.                 )
     
132.             temp = Teamleader(name, grade, year)
     
133.             self.workers.append(temp)
     
134.             self.occupation_pool[job].append(temp)
     
135.         elif job == "M":
     
136.             while grade > Manager.max_grade:
     
137.                 grade = self.input_plus_int(
     
138.                     f"该职位最高级别为{Manager.max_grade}，请重新录入级别："
     
139.                 )
     
140.             temp = Manager(name, grade, year)
     
141.             self.workers.append(temp)
     
142.             self.occupation_pool[job].append(temp)
     
143.         else:
     
144.             print("暂无该职位！")
     
145.             return
     
146.         print(f"录入成功！姓名：{temp.name}，工号：{temp.uid}，薪资：{temp.salary()}")
     
147.         return
     
148. 
     
149.     def inquire(self) -> None:
     
150.         while True:
     
151.             op = input("1.员工查询；2.职位查询：")
     
152.             if op in ["1", "2"]:
     
153.                 break
     
154.             print("请输入1或2！")
     
155.         if op == "1":
     
156.             i, temp = self.findWorker()
     
157.             if i == -1:
     
158.                 return
     
159.             temp.get_name()
     
160.             temp.get_job()
     
161.             temp.get_grade()
     
162.             temp.get_year()
     
163.             temp.get_salary()
     
164.         else:
     
165.             job = input("职位（E.普通员工；T.组长；M.经理）：")
     
166.             if job == "E":
     
167.                 if self.occupation_pool[job] == []:
     
168.                     print("目前公司没有普通员工&#128517;！")
     
169.                     return
     
170.                 print(f"目前普通员工有 {len(self.occupation_pool[job])} 人：")
     
171.             elif job == "T":
     
172.                 if self.occupation_pool[job] == []:
     
173.                     print("目前公司没有组长！")
     
174.                     return
     
175.                 print(f"目前组长有 {len(self.occupation_pool[job])} 人：")
     
176.             elif job == "M":
     
177.                 if self.occupation_pool[job] == []:
     
178.                     print("目前公司没有经理！")
     
179.                     return
     
180.                 print(f"目前经理有 {len(self.occupation_pool[job])} 人：")
     
181.             for worker in self.occupation_pool[job]:
     
182.                 print(f"{worker.uid} - {worker.name}")
     
183. 
     
184.     def upgrade(self):
     
185.         i, temp = self.findWorker()
     
186.         if i == -1:
     
187.             return
     
188.         level = self.input_plus_int("请输入需要增加的级数：")
     
189.         if temp.cgrade(level):
     
190.             print("升级成功！")
     
191. 
     
192.     def degrade(self):
     
193.         i, temp = self.findWorker()
     
194.         if i == -1:
     
195.             return
     
196.         level = self.input_plus_int("请输入需要减少的级数：")
     
197.         if temp.cgrade(-level):
     
198.             print("降级成功！")
     
199. 
     
200.     def menu(self):
     
201.         while True:
     
202.             op = self.input_plus_int("1.录入；2.查询；3.升级；4.降级；5.退出：")
     
203.             if op == 1:
     
204.                 self.enroll()
     
205.             elif op == 2:
     
206.                 self.inquire()
     
207.             elif op == 3:
     
208.                 self.upgrade()
     
209.             elif op == 4:
     
210.                 self.degrade()
     
211.             elif op == 5:
     
212.                 break
     
213. 
     
214. 
     
215. def main():
     
216.     m = Manage()
     
217.     m.menu()
     
218. 
     
219. 
     
220. main()

复制代码

伽蓝Python

请回复您的答案^_^

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

第 0 题的答案是：
1、通过重写的方式，2、在定义函数时就定义好函数的多态性，3、通过鸭子类型
第 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 题的代码写在下方：
class Employee:
    # 定义员工等级和对应的工资
    max_grade = {'E': 10, 'T': 6, 'M': 3}
    # 定义员工等级升级
    up_grade = {'E': 'T', 'T': 'M', 'M': None}
    # 定义员工等级降级
    down_grade = {'M': 'T', 'T': 'E', 'E': None}

    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):
        # 返回员工ID
        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 get_salary(self):
        # 根据员工职位计算工资
        # 如果职位是E，则返回3000 + 500 * 等级 + 50 * 工龄
        if self.job == 'E':
            return 3000 + 500 * self.grade + 50 * self.year
        # 如果职位是T，则返回4000 + 800 * 等级 + 100 * 工龄
        elif self.job == 'T':
            return 4000 + 800 * self.grade + 100 * self.year
        # 如果职位是M，则返回5000 + 1000 * (等级 + 工龄)
        elif self.job =='M':
            return 5000 + 1000 * (self.grade + self.year)
        # 否则返回0
        else:
            return 0
class Main:
    def __init__(self):
        self.employee_info = {}
        # 定义一个变量，用于存储员工编号的起始值
        self.begin_uid = 10000
    def input_info(self):
        # 输入姓名
        name = input('姓名：').strip()
        # 输入职位，直到输入正确为止
        while True:
            job = input('职位（E普通员工；T组长；M经理）：').upper()
            # 判断输入的职位是否正确
            if job in ['E', 'T', 'M']:
                break
            else:
                print('输入错误，请重新输入')
        # 输入工龄
        year = int(input('工龄：'))
        max_grade = Employee.max_grade[job]
        # 输入级别，直到输入正确为止
        while True:
            grade = int(input('级别：'))
            # 判断输入的级别是否正确
            if 1 <= grade <= max_grade:
                break
            else:
                print(f'该职位最高级别为{max_grade}，请重新输入')
        uid = self.begin_uid
        new_employee = Employee(uid, name, job, grade, year)
        salary = new_employee.get_salary()
        self.employee_info[uid] = new_employee
        self.begin_uid += 1
        print(f'录入成功！姓名:{name}, 工号：{uid}, 薪资：{salary}')
    def search_info(self):
        choice = int(input('1、员工查询；2、职位查询：'))
        if choice == 1:
            uid = int(input('请输入员工编号：'))
            if uid in self.employee_info:
                print(f'姓名：{self.employee_info[uid].get_name()}\n职位：{self.employee_info[uid].get_job()}\n级别：{self.employee_info[uid].get_grade()}\n工龄：{self.employee_info[uid].get_year()}\n薪资：{self.employee_info[uid].get_salary()}')
            else:
                print('该工号不存在')
        elif choice == 2:
            job = input('职位（E普通员工；T组长；M经理）：').upper()
            if job == 'E':
                count = 0
                employees = []
                for uid, employee in self.employee_info.items():
                    if employee.get_job() == job:
                        count += 1
                        employees.append(f'{employee.get_uid()} - {employee.get_name()}')
                if count > 0:
                    print(f'目前普通员工共有{count}人:\n{employees}')
                else:
                    print('目前没有普通员工')
            elif job == 'T':
                count = 0
                employees = []
                for uid, employee in self.employee_info.items():
                    if employee.get_job() == job:
                        count += 1
                        employees.append(f'{employee.get_uid()} - {employee.get_name()}')
                if count > 0:
                    print(f'目前组长共有{count}人:\n{employees}')
                else:
                    print('目前公司没有组长')
            elif job == 'M':
                count = 0
                employees = []
                for uid, employee in self.employee_info.items():
                    if employee.get_job() == job:
                        count += 1
                        employees.append(f'{employee.get_uid()} - {employee.get_name()}')
                if count > 0:
                    print(f'目前经理共有{count}人:\n{employees}')
                else:
                    print('目前公司没有经理')
            else:
                print('目前公司没有这个职位')
    def up_grade(self):
        while True:
            uid = int(input('请输入工号：'))
            if uid in self.employee_info:
                break
            else:
                print('该工号不存在')
        print(f'{self.employee_info[uid].get_name()}， 工号：{uid}， 当前职位：{self.employee_info[uid].get_job()}{self.employee_info[uid].get_grade()}，当前薪资：{self.employee_info[uid].get_salary()}')
        old_salary = self.employee_info[uid].get_salary()
        add_grade = int(input('请输入要增加的级数：'))
        print('升级成功！')
        if self.employee_info[uid].get_job() == 'E':
            if self.employee_info[uid].get_grade() + add_grade > 10:
                self.employee_info[uid].job = 'T'
                self.employee_info[uid].grade = 1
            else:
                self.employee_info[uid].grade += add_grade
        elif self.employee_info[uid].get_job() == 'T':
            if self.employee_info[uid].get_grade() + add_grade > 6:
                self.employee_info[uid].job = 'M'
                self.employee_info[uid].grade = 1
            else:
                self.employee_info[uid].grade += add_grade
        elif self.employee_info[uid].get_job() == 'M':
            if self.employee_info[uid].get_grade() + add_grade > 3:
                print('该员工已经是最高级别了')
                return
            else:
                self.employee_info[uid].grade += add_grade
        print(f'{self.employee_info[uid].get_name()}， 工号：{uid}， 升级后职位：{self.employee_info[uid].get_job()}{self.employee_info[uid].get_grade()}，升级后薪资：{self.employee_info[uid].get_salary()}(+{self.employee_info[uid].get_salary() - old_salary})')
    def down_grade(self):
        while True:
            uid = int(input('请输入工号：'))
            if uid in self.employee_info:
                break
            else:
                print('该工号不存在')
        print(f'{self.employee_info[uid].get_name()}， 工号：{uid}， 当前职位：{self.employee_info[uid].get_job()}{self.employee_info[uid].get_grade()}，当前薪资：{self.employee_info[uid].get_salary()}')
        old_salary = self.employee_info[uid].get_salary()
        down_grade = int(input('请输入要降低的级数：'))
        print('降级成功！')
        if self.employee_info[uid].get_job() == 'E':
            if self.employee_info[uid].get_grade() - down_grade < 1:
                print('该员工已经是最低级别了')
                return
            else:
                self.employee_info[uid].grade -= down_grade
        elif self.employee_info[uid].get_job() == 'T':
            if self.employee_info[uid].get_grade() - down_grade < 1:
                self.employee_info[uid].job = 'E'
                self.employee_info[uid].grade = 10
            else:
                self.employee_info[uid].grade -= down_grade
        elif self.employee_info[uid].get_job() == 'M':
            if self.employee_info[uid].get_grade() - down_grade < 1:
                self.employee_info[uid].job = 'T'
                self.employee_info[uid].grade = 6
            else:
                self.employee_info[uid].grade -= down_grade
        print(f'{self.employee_info[uid].get_name()}， 工号：{uid}， 降级后职位：{self.employee_info[uid].get_job()}{self.employee_info[uid].get_grade()}，降级后薪资：{self.employee_info[uid].get_salary()}(-{old_salary - self.employee_info[uid].get_salary()})')
main = Main()
while True:
    choice = int(input('1、录入； 2、查询； 3、升级； 4、降级： 5、退出：'))
    if choice == 1:
        main.input_info()
    elif choice == 2:
        main.search_info()
    elif choice == 3:
        main.up_grade()
    elif choice == 4:
        main.down_grade()
    elif choice == 5:
        break
    else:
        print('输入错误')

闻人不语

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

一只槐安

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

LEEFEI571

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

灿烂千阳~

请回复您的答案^_^

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

第 0 题的答案是：
Python 的多态性主要通过 鸭子类型（Duck Typing） 体现。它不强制要求对象继承自某个特定类，而是关注对象的行为（即方法或属性的存在性）。
例如，只要一个对象实现了 __len__() 方法，它就可以被 len() 函数调用；只要实现了 __add__() 方法，就能使用 + 运算符。这种基于行为而非继承的多态性，使得代码更加灵活。
第 1 题的答案是：
代码复用性：同一接口可以处理多种类型的对象。

扩展性：新增类时无需修改现有代码，只需实现约定的接口。

解耦：调用方依赖抽象行为，而非具体实现，降低了模块间的耦合度。
第 2 题的答案是：
是的。这种现象是 运算符重载 的体现，而运算符重载本质上是一种多态。

1 + 1 调用 int 的 __add__，结果为 2。

'1' + '1' 调用 str 的 __add__，结果为 '11'。
Python 根据操作数的类型动态选择对应的方法，这正是多态的特性。
第 3 题的答案是：
鸭子类型的名字来源于谚语：

"If it walks like a duck and quacks like a duck, then it must be a duck."
（如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子。）

在编程中，只要对象的行为符合预期（如实现了特定方法），就可以被当作目标类型使用，无需显式继承。
第 4 题的答案是：
鸭子类型降低了耦合度。

低耦合：模块间依赖的是行为（方法/属性），而非具体类。调用方无需关心对象的具体类型，只需确保它实现了所需方法。
第 5 题的答案是：
是的
-------- 动动手 --------

请将第 0 题的代码写在下方：
class Staff:
    def __init__(self,name,job,grade,year,uid):
        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):
        if self.job == 'E':
            salary = 3000 + 500 * self.grade + 50 * self.year
        elif self.job == 'T':
            salary = 4000 + 800 * self.grade + 100 * self.year
        elif self.job == 'M':
            salary = 5000 + 1000 * self.grade + 1000 * self.year
        return salary
class Management:
    def __init__(self):
        self.members = {}
        self.uid = 10000
        
    def welcome(self):
        while True:
            choice = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
            if choice == '1':
                self.entry()
            elif choice == '2':
                self.query()
            elif choice == '3':
                self.upgrade()
            elif choice == '4':
                self.degrade()
            elif choice == '5':
                break
            
    def entry(self):
        name = input("姓名：")
        job = input("职位（E.普通员工;T.组长;M.经理）：")
        year = int(input("工龄："))
        grade = int(input("级别："))
        if job == 'E':
            while True:
                if 1 <= grade <= 10:
                    break
                else:
                    grade = int(input("该职位最高级别为10，请重新录入级别："))
        elif job == 'T':
            while True:
                if 1 <= grade <= 6:
                    break
                else:
                    grade = int(input("该职位最高级别为6，请重新录入级别："))
        elif job == 'M':
            while True:
                if 1 <= grade <= 3:
                    break
                else:
                    grade = int(input("该职位最高级别为3，请重新录入级别："))
        staff_member = Staff(name,job,grade,year,self.uid)
        self.members[self.uid] = staff_member
        print(f"录入成功！姓名：{name}，工号：{self.uid}，薪资：{staff_member.salary()}")
        self.uid += 1

    def query(self):
        choice = input("1.员工查询;2.职位查询：")
        if choice == '1':
            uid = int(input("请输入工号："))
            if uid in self.members:
                print(f"姓名：{self.members[uid].get_name()}")
                print(f"职位：{self.members[uid].get_job()}")
                print(f"级别：{self.members[uid].get_grade()}")
                print(f"工龄：{self.members[uid].get_year()}")
                print(f"薪资：{self.members[uid].salary()}")
            else:
                print("该工号不存在！")
        elif choice == '2':
            job = input(f"职位（E.普通员工;T.组长;M.经理）：")
            if job == 'E':
                E_num = 0
                for each in self.members:
                    if self.members[each].get_job() == 'E':
                        E_num += 1
                if E_num == 0:
                    print("目前公司没有普通员工！")
                else:
                    print(f"目前普通员工共有 {E_num} 人：")
                    for each in self.members:
                        if self.members[each].get_job() == 'E':
                            print(f"{self.members[each].get_uid()} - {self.members[each].get_name()}")
            elif job == 'T':
                T_num = 0
                for each in self.members:
                    if self.members[each].get_job() == 'T':
                        T_num += 1
                if T_num == 0:
                    print("目前公司没有组长！")
                else:
                    print(f"目前组长共有 {T_num} 人：")
                    for each in self.members:
                        if self.members[each].get_job() == 'T':
                            print(f"{self.members[each].get_uid()} - {self.members[each].get_name()}")
            elif job == 'M':
                M_num = 0
                for each in self.members:
                    if self.members[each].get_job() == 'M':
                        M_num += 1
                if M_num == 0:
                    print("目前公司没有经理！")
                else:
                    print(f"目前经理共有 {M_num} 人：")
                    for each in self.members:
                        if self.members[each].get_job() == 'M':
                            print(f"{self.members[each].get_uid()} - {self.members[each].get_name()}")

    def upgrade(self):
        uid = int(input("请输入工号："))
        if uid in self.members:
            print(f"{self.members[uid].get_name()}，工号：{self.members[uid].get_uid()}，当前职位：{self.members[uid].get_job()}{self.members[uid].get_grade()}，当前薪资：{self.members[uid].salary()}")
        else:
            print("该工号不存在！")
            return
        variation = int(input("请输入需要增加的级数："))
        salary = self.members[uid].salary()
        if self.members[uid].job == 'E':
            if variation + self.members[uid].grade > 10:
                self.members[uid].job = 'T'
                self.members[uid].grade = 1
            else:
                self.members[uid].grade += variation
        elif self.members[uid].job == 'T':
            if variation + self.members[uid].grade > 6:
                self.members[uid].job = 'M'
                self.members[uid].grade = 1
            else:
                self.members[uid].grade += variation
        elif self.members[uid].job == 'M':
            self.members[uid].grade += variation
        print("升级成功！")
        print(f"{self.members[uid].get_name()}，工号：{self.members[uid].get_uid()}，升级后职位：{self.members[uid].get_job()}{self.members[uid].get_grade()}，升级后薪资：{self.members[uid].salary()}(+{self.members[uid].salary()-salary})")
      

    def degrade(self):
        uid = int(input("请输入工号："))
        if uid in self.members:
            print(f"{self.members[uid].get_name()}，工号：{self.members[uid].get_uid()}，当前职位：{self.members[uid].get_job()}{self.members[uid].get_grade()}，当前薪资：{self.members[uid].salary()}")
        else:
            print("该工号不存在！")
            return
        variation = int(input("请输入需要减少的级数："))
        salary = self.members[uid].salary()
        if self.members[uid].job == 'E':
            self.members[uid].grade -= variation
        elif self.members[uid].job == 'T':
            if self.members[uid].grade - variation < 1:
                self.members[uid].job = 'E'
                self.members[uid].grade = 10
            else:
                self.members[uid].grade -= variation
        elif self.members[uid].job == 'M':
            if self.members[uid].grade - variation < 1:
                self.members[uid].job = 'T'
                self.members[uid].grade = 6
        print("降级成功！")
        print(f"{self.members[uid].get_name()}，工号：{self.members[uid].get_uid()}，降级后职位：{self.members[uid].get_job()}{self.members[uid].get_grade()}，降级后薪资：{self.members[uid].salary()}(-{salary-self.members[uid].salary()})")
      
def main():
    m = Management()
    m.welcome()

JayWong2177

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

船长小黑胖子

请回复您的答案^_^

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

第 0 题的答案是：
通过继承，或者相同的方法名。

第 1 题的答案是：
简洁。

第 2 题的答案是：
可以。


第 3 题的答案是：
如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子。


第 4 题的答案是：
增强了内聚。


第 5 题的答案是：
不是

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

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