请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
只需要对象的方法符合要求，就可以调用
第 1 题的答案是：
使代码更加模块化、易于扩展和维护。
第 2 题的答案是：
可以
第 3 题的答案是：
“如果它走起来像鸭子，叫起来也像鸭子，那么它很可能就是一只鸭子。”
这句话强调的是行为和接口的重要性，而不是对象的具体类型。
第 4 题的答案是：
鸭子类型增强了低耦合度：通过关注对象的行为而非具体类型，
鸭子类型减少了模块之间的硬编码依赖，提高了系统的灵活性和可维护性。
鸭子类型不直接影响内聚性：内聚性主要关注模块内的功能联系，鸭子类
型更多地帮助实现低耦合，但需要结合良好的设计来实现高内聚。
第 5 题的答案是：
是
-------- 动动手 --------
请将第 0 题的代码写在下方：
1
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
具有同样名字的方法，可以有不同的作用
第 1 题的答案是：
同样方法不同作用
第 2 题的答案是：
可以
第 3 题的答案是：
bzd
第 4 题的答案是：
低耦合
第 5 题的答案是：
不是
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 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)
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
继承和方法重写，鸭子类型
第 1 题的答案是：
一个接口面对不同对象
第 2 题的答案是：
可以，+号和==号都多态
第 3 题的答案是：
第 4 题的答案是：
增强了
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
不同对象传入同一个类中调用各自不同的方法
第 1 题的答案是：
减少代码冗余
第 2 题的答案是：
不能,从结果来看,两者没有任何关系
第 3 题的答案是：
不知道
第 4 题的答案是：
降低耦合
第 5 题的答案是：
是的
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 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# 通过字典键访问值
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
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:
if current_job_index < len(job_order) - 1:
current_job_index += 1
self.job = job_order
new_grade = 1# 升为上一职位的最低级
else:
new_grade = job_max_grade
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
new_grade = job_max_grade# 降为下一职位的最高级
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 = 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
print(member.get_uid(c2_uid))
else:
print('该工号不存在')
elif c2 == "2":
c2_job, _ = self.get_valid_job()
job_title = job_dict
job_members =
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
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
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()
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
-------- 问答题 --------
第 0 题的答案是：
通过同一函数名操作不同类
第 1 题的答案是：
减少代码量
第 2 题的答案是：
不能
第 3 题的答案是：
If it walks like a duck and quacks like a duck, then it must be a duck.
第 4 题的答案是：
降低耦合度
第 5 题的答案是：
不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
def create_uid():
uid = 9999
def inner() -> int:
nonlocal uid
uid += 1
return uid
return inner
ct_uid = create_uid()
class Worker:
def __init__(self, name: str, job: str, grade: int, year: int) -> None:
self.name = name
self.job = job
self.grade = grade
self.year = year
self.uid = ct_uid()
def get_uid(self):
print(f"工号：{self.uid}")
def get_name(self):
print(f"姓名：{self.name}")
def get_job(self):
print(f"职位：{self.job}")
def get_grade(self):
print(f"级别：{self.grade}")
def get_year(self):
print(f"工龄：{self.year}")
class GetSalaryMixin:
def get_salary(self):
print(f"薪资：{self.salary()}")
class ChangeGradeMixin:
def cgrade(self, rank: int) -> bool:
self.grade += rank
if self.grade < 1:
self.grade = 1
elif self.grade > self.max_grade:
self.grade = self.max_grade
return True
class Employee(ChangeGradeMixin, GetSalaryMixin, Worker):
max_grade = 10
def __init__(self, name: str, grade: int, year: int) -> None:
super().__init__(name, "E", grade, year)
def salary(self):
return 3000 + 500 * self.grade + 50 * self.year
class Teamleader(ChangeGradeMixin, GetSalaryMixin, Worker):
max_grade = 6
def __init__(self, name: str, grade: int, year: int) -> None:
super().__init__(name, "T", grade, year)
def salary(self):
return 4000 + 800 * self.grade + 100 * self.year
class Manager(ChangeGradeMixin, GetSalaryMixin, Worker):
max_grade = 3
def __init__(self, name: str, grade: int, year: int) -> None:
super().__init__(name, "M", grade, year)
def salary(self):
return 5000 + 1000 * (self.grade + self.year)
class Manage:
workers: list = []
occupation_pool: dict] = {
"E": [],
"T": [],
"M": [],
}
def input_plus_int(self, s: str) -> int:
while True:
try:
num = int(input(s))
if num < 0:
raise ValueError
return num
except ValueError:
print("请用正整数输入！")
except KeyboardInterrupt:
print("\n操作被用户中断")
raise
def findWorker(self) -> tuple:
uid = self.input_plus_int("请输入工号：")
for i, worker in enumerate(self.workers):
if worker.uid == uid:
return i, worker
else:
print("该工号不存在！")
return -1, worker
def enroll(self) -> None:
name = input("姓名：")
job = input("职位（E.普通员工；T.组长；M.经理）：")
year = self.input_plus_int("工龄：")
grade = self.input_plus_int("级别：")
if job == "E":
while grade > Employee.max_grade:
grade = self.input_plus_int(
f"该职位最高级别为{Employee.max_grade}，请重新录入级别："
)
temp = Employee(name, grade, year)
self.workers.append(temp)
self.occupation_pool.append(temp)
elif job == "T":
while grade > Teamleader.max_grade:
grade = self.input_plus_int(
f"该职位最高级别为{Teamleader.max_grade}，请重新录入级别："
)
temp = Teamleader(name, grade, year)
self.workers.append(temp)
self.occupation_pool.append(temp)
elif job == "M":
while grade > Manager.max_grade:
grade = self.input_plus_int(
f"该职位最高级别为{Manager.max_grade}，请重新录入级别："
)
temp = Manager(name, grade, year)
self.workers.append(temp)
self.occupation_pool.append(temp)
else:
print("暂无该职位！")
return
print(f"录入成功！姓名：{temp.name}，工号：{temp.uid}，薪资：{temp.salary()}")
return
def inquire(self) -> None:
while True:
op = input("1.员工查询；2.职位查询：")
if op in ["1", "2"]:
break
print("请输入1或2！")
if op == "1":
i, temp = self.findWorker()
if i == -1:
return
temp.get_name()
temp.get_job()
temp.get_grade()
temp.get_year()
temp.get_salary()
else:
job = input("职位（E.普通员工；T.组长；M.经理）：")
if job == "E":
if self.occupation_pool == []:
print("目前公司没有普通员工😅！")
return
print(f"目前普通员工有 {len(self.occupation_pool)} 人：")
elif job == "T":
if self.occupation_pool == []:
print("目前公司没有组长！")
return
print(f"目前组长有 {len(self.occupation_pool)} 人：")
elif job == "M":
if self.occupation_pool == []:
print("目前公司没有经理！")
return
print(f"目前经理有 {len(self.occupation_pool)} 人：")
for worker in self.occupation_pool:
print(f"{worker.uid} - {worker.name}")
def upgrade(self):
i, temp = self.findWorker()
if i == -1:
return
level = self.input_plus_int("请输入需要增加的级数：")
if temp.cgrade(level):
print("升级成功！")
def degrade(self):
i, temp = self.findWorker()
if i == -1:
return
level = self.input_plus_int("请输入需要减少的级数：")
if temp.cgrade(-level):
print("降级成功！")
def menu(self):
while True:
op = self.input_plus_int("1.录入；2.查询；3.升级；4.降级；5.退出：")
if op == 1:
self.enroll()
elif op == 2:
self.inquire()
elif op == 3:
self.upgrade()
elif op == 4:
self.degrade()
elif op == 5:
break
def main():
m = Manage()
m.menu()
main()
请回复您的答案^_^
-------- 问答题 --------
第 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
# 输入级别，直到输入正确为止
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 = 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.get_name()}\n职位：{self.employee_info.get_job()}\n级别：{self.employee_info.get_grade()}\n工龄：{self.employee_info.get_year()}\n薪资：{self.employee_info.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.get_name()}， 工号：{uid}， 当前职位：{self.employee_info.get_job()}{self.employee_info.get_grade()}，当前薪资：{self.employee_info.get_salary()}')
old_salary = self.employee_info.get_salary()
add_grade = int(input('请输入要增加的级数：'))
print('升级成功！')
if self.employee_info.get_job() == 'E':
if self.employee_info.get_grade() + add_grade > 10:
self.employee_info.job = 'T'
self.employee_info.grade = 1
else:
self.employee_info.grade += add_grade
elif self.employee_info.get_job() == 'T':
if self.employee_info.get_grade() + add_grade > 6:
self.employee_info.job = 'M'
self.employee_info.grade = 1
else:
self.employee_info.grade += add_grade
elif self.employee_info.get_job() == 'M':
if self.employee_info.get_grade() + add_grade > 3:
print('该员工已经是最高级别了')
return
else:
self.employee_info.grade += add_grade
print(f'{self.employee_info.get_name()}， 工号：{uid}， 升级后职位：{self.employee_info.get_job()}{self.employee_info.get_grade()}，升级后薪资：{self.employee_info.get_salary()}(+{self.employee_info.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.get_name()}， 工号：{uid}， 当前职位：{self.employee_info.get_job()}{self.employee_info.get_grade()}，当前薪资：{self.employee_info.get_salary()}')
old_salary = self.employee_info.get_salary()
down_grade = int(input('请输入要降低的级数：'))
print('降级成功！')
if self.employee_info.get_job() == 'E':
if self.employee_info.get_grade() - down_grade < 1:
print('该员工已经是最低级别了')
return
else:
self.employee_info.grade -= down_grade
elif self.employee_info.get_job() == 'T':
if self.employee_info.get_grade() - down_grade < 1:
self.employee_info.job = 'E'
self.employee_info.grade = 10
else:
self.employee_info.grade -= down_grade
elif self.employee_info.get_job() == 'M':
if self.employee_info.get_grade() - down_grade < 1:
self.employee_info.job = 'T'
self.employee_info.grade = 6
else:
self.employee_info.grade -= down_grade
print(f'{self.employee_info.get_name()}， 工号：{uid}， 降级后职位：{self.employee_info.get_job()}{self.employee_info.get_grade()}，降级后薪资：{self.employee_info.get_salary()}(-{old_salary - self.employee_info.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 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 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 = 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.get_name()}")
print(f"职位：{self.members.get_job()}")
print(f"级别：{self.members.get_grade()}")
print(f"工龄：{self.members.get_year()}")
print(f"薪资：{self.members.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.get_job() == 'E':
E_num += 1
if E_num == 0:
print("目前公司没有普通员工！")
else:
print(f"目前普通员工共有 {E_num} 人：")
for each in self.members:
if self.members.get_job() == 'E':
print(f"{self.members.get_uid()} - {self.members.get_name()}")
elif job == 'T':
T_num = 0
for each in self.members:
if self.members.get_job() == 'T':
T_num += 1
if T_num == 0:
print("目前公司没有组长！")
else:
print(f"目前组长共有 {T_num} 人：")
for each in self.members:
if self.members.get_job() == 'T':
print(f"{self.members.get_uid()} - {self.members.get_name()}")
elif job == 'M':
M_num = 0
for each in self.members:
if self.members.get_job() == 'M':
M_num += 1
if M_num == 0:
print("目前公司没有经理！")
else:
print(f"目前经理共有 {M_num} 人：")
for each in self.members:
if self.members.get_job() == 'M':
print(f"{self.members.get_uid()} - {self.members.get_name()}")
def upgrade(self):
uid = int(input("请输入工号："))
if uid in self.members:
print(f"{self.members.get_name()}，工号：{self.members.get_uid()}，当前职位：{self.members.get_job()}{self.members.get_grade()}，当前薪资：{self.members.salary()}")
else:
print("该工号不存在！")
return
variation = int(input("请输入需要增加的级数："))
salary = self.members.salary()
if self.members.job == 'E':
if variation + self.members.grade > 10:
self.members.job = 'T'
self.members.grade = 1
else:
self.members.grade += variation
elif self.members.job == 'T':
if variation + self.members.grade > 6:
self.members.job = 'M'
self.members.grade = 1
else:
self.members.grade += variation
elif self.members.job == 'M':
self.members.grade += variation
print("升级成功！")
print(f"{self.members.get_name()}，工号：{self.members.get_uid()}，升级后职位：{self.members.get_job()}{self.members.get_grade()}，升级后薪资：{self.members.salary()}(+{self.members.salary()-salary})")
def degrade(self):
uid = int(input("请输入工号："))
if uid in self.members:
print(f"{self.members.get_name()}，工号：{self.members.get_uid()}，当前职位：{self.members.get_job()}{self.members.get_grade()}，当前薪资：{self.members.salary()}")
else:
print("该工号不存在！")
return
variation = int(input("请输入需要减少的级数："))
salary = self.members.salary()
if self.members.job == 'E':
self.members.grade -= variation
elif self.members.job == 'T':
if self.members.grade - variation < 1:
self.members.job = 'E'
self.members.grade = 10
else:
self.members.grade -= variation
elif self.members.job == 'M':
if self.members.grade - variation < 1:
self.members.job = 'T'
self.members.grade = 6
print("降级成功！")
print(f"{self.members.get_name()}，工号：{self.members.get_uid()}，降级后职位：{self.members.get_job()}{self.members.get_grade()}，降级后薪资：{self.members.salary()}(-{salary-self.members.salary()})")
def main():
m = Management()
m.welcome()
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
通过继承，或者相同的方法名。
第 1 题的答案是：
简洁。
第 2 题的答案是：
可以。
第 3 题的答案是：
如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子。
第 4 题的答案是：
增强了内聚。
第 5 题的答案是：
不是
-------- 动动手 --------
请将第 0 题的代码写在下方：