请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
灵活
第 3 题的答案是：
可以
第 4 题的答案是：
第 5 题的答案是：
不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
同一函数名，不同对象给出不同结果
第 1 题的答案是：
灵活多变，功能扩展性强
第 2 题的答案是：
可以
第 3 题的答案是：
宁可请求原谅，不要事后许可
第 4 题的答案是：
鸭子类型降低了耦合度
第 5 题的答案是：
不算
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：在Python中，多态性（Polymorphism）是一种允许我们使用统一的接口来执行多种类型的操作的能力。多态性主要体现在继承和函数重载（在某些情况下）上。
第 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 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 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 题的代码写在下方：
class Member:
def __init__(self,name,grade,year,uid):
self.name = name
self.grade = grade
self.year = year
self.uid = uid
class Employee(Member):
job = 'E'
class Teamleader(Member):
job = 'T'
class Manager(Member):
job = 'M'
class Main:
message_d = {}
uid = 10000
message_d_job = {'E':[],'T':[],'M':[]}
def choose(self):
while True:
function = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
if function == '1':
self.enlist()
elif function == '2':
self.get()
elif function == '3':
self.upgrate()
elif function == '4':
self.downgrate()
else:
print("已退出")
break
def enlist(self):
name = input("姓名:")
job = input("职位(E.普通员工；T.组长;M.经理):")
while job not in ('E','T','M'):
job = input("输入错误，请重试:")
year = int(input("工龄:"))
grade = int(input("级别:"))
if job == 'E':
self.message_d = Employee(name,grade,year,self.uid)
elif job == 'T':
self.message_d = Teamleader(name,grade,year,self.uid)
else:
self.message_d = Manager(name,grade,year,self.uid)
self.message_d_job.append((self.uid,name))
self.salary(self.uid)
print(f"录入成功!姓名:{name},工号:{self.uid},薪资:{self.message_d.salary}")
self.uid += 1
def get(self):
sub_function = input("1.员工查询；2.职位查询:")
if sub_function == '1':
uid = int(input("请输入工号:"))
if uid in self.message_d:
self.get_name(uid)
self.get_job(uid)
self.get_grade(uid)
self.get_year(uid)
salary = self.salary(uid)
print(f'薪资:{salary}')
else:
print("该工号不存在!")
else:
job = input("职位(E.普通员工；T.组长；M.经理):")
self.get_uid(job)
def get_uid(self,job):
element = self.message_d_job
length = len(element)
if job == 'E':
member = '普通员工'
elif job == 'T':
member = '组长'
else:
member = '经理'
print(f"目前{member}共有{length}人:")
for i in element:
print(i,' - ',i)
def get_name(self,uid):
print('姓名:',self.message_d.name)
def get_job(self,uid):
print("职位:",self.message_d.job)
def get_grade(self,uid):
print("级别:",self.message_d.grade)
def get_year(self,uid):
print("工龄:",self.message_d.year)
def salary(self,uid):
job = self.message_d.job
year = self.message_d.year
grade = self.message_d.grade
if job == 'E':
func = lambda x,y:3000 + 500 * y + 50 * x
elif job == 'T':
func = lambda x,y:4000 + 800 * y + 100 * x
else:
func = lambda x,y:5000 + 1000 * ( x + y )
salary = func(year,grade)
self.message_d.salary = salary
return salary
def upgrate(self):
uid = int(input("请输入工号:"))
_ = self.message_d
if uid in self.message_d:
print(f"{_.name},工号:{_.uid},当前职位:{_.job}{_.grade},当前薪资:{_.salary}")
up = int(input("请输入需要增加的级数:"))
a = up + _.grade
job = _.job
if job == 'E' and a > 10:
a = 1
job = 'T'
elif job == 'T' and a > 6:
a = 1
job = 'M'
elif job == 'M' and a > 3:
print("超过最高职位，无法执行")
_.grade = a
_.job = job
_.salary = self.salary(uid)
print("升级成功!")
print(f"{_.name},工号:{_.uid},升级后职位:{_.job}{_.grade},升级后薪资:{_.salary}")
else:
print("该工号不存在")
def downgrate(self):
uid = int(input("请输入工号:"))
_ = self.message_d
if uid in self.message_d:
print(f"{_.name},工号:{_.uid},当前职位:{_.job}{_.grade},当前薪资:{_.salary}")
down = int(input("请输入需要减少的级数:"))
a = _.grade - down
job = _.job
if job == 'E' and a <= 0:
print("低于最低职位，无法执行!")
elif job == 'T' and a <= 0:
a = 10
job = 'E'
elif job == 'M' and a <= 0:
a = 6
job = 'T'
_.grade = a
_.job = job
_.salary = self.salary(uid)
print("升级成功!")
print(f"{_.name},工号:{_.uid},降级后职位:{_.job}{_.grade},降级后薪资:{_.salary}")
else:
print("该工号不存在!")
def main():
m = Main()
m.choose()
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：同一个符号、函数不同功能
第 1 题的答案是：灵活
第 2 题的答案是：可以
第 3 题的答案是：不知道
第 4 题的答案是：降低耦合度
第 5 题的答案是：不属于，这就是一个功能加法
-------- 动动手 --------
请将第 0 题的代码写在下方：
# 员工信息
class Yuangong:
def __init__(self, uid, name, job, grade, year):
self.uid = uid
self.name = name
self.job = job
self.grade = grade
self.year = year
self.salary = 0
#薪资计算
def salary(self):
if job == "E":
sa = 3000 + 500 * self.grade + 50 * self.year
if job == "T":
sa = 4000 + 800 * self.grade + 100 * self.year
if job == "M":
sa = 5000 + 1000 * (self.grade + self.year)
return sa
class Guanli(Yuangong):
def __init__(self):
self.yuangong_xinxi = {}
self.uid = 10000
#录入功能
def luru(self):
name = input("姓名：")
job = input("职位（E.普通员工；T.组长；M.经理）：")
while job not in ("E", "T", "M"):
job = input("请重新录入职位（E.普通员工；T.组长；M.经理）：")
grade = int(input("级别：") )
while job == 'E' and not (grade > 0 and grade <= 10):
grade = int(input("该职位最高级别为10，请重新录入级别：") )
while job == 'T' and not (grade > 0 and grade <= 6):
grade = int(input("该职位最高级别为6，请重新录入级别：") )
while job == 'M' and not (grade > 0 and grade <= 3):
grade = int(input("该职位最高级别为3，请重新录入级别：") )
year = int(input("工龄：") )
yuangong = Yuangong(self.uid, name, job, grade, year)
sal = yuangong.salary()
#yuangong.salary = sal
self.yuangong_xinxi = yuangong
print(f"录入成功！姓名：{name}，工号：{self.uid}，薪资：{sal}")
self.uid += 1
#查询功能
#def chaxun(self):
def main():
guanli = Guanli()
a = 0
while a != '5':
a = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
if a == '1':
guanli.luru()
if a == '5':
break
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：方法重写
第 1 题的答案是：多态最核心的优势，用一句话概括就是：它消灭了“满屏的 if...elif...else”，让你写的代码“对扩展开放，对修改封闭”（开闭原则）。
第 2 题的答案是：可以
第 3 题的答案是：如果它走路像鸭子，叫声像鸭子，那它就是一只鸭子
第 4 题的答案是：鸭子类型同时做到了“降低耦合度”和“增强内聚度”
第 5 题的答案是：不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
class 普通员工:
最高级别 = 10
def __init__(self, 工号, 姓名, 级别, 工龄):
self.工号 = 工号
self.姓名 = 姓名
self.级别 = 级别
self.工龄 = 工龄
self.职位 = 'E'
def 获取工号(self):return self.工号
def 获取姓名(self):return self.姓名
def 获取职位(self):return self.职位
def 获取级别(self):return self.级别
def 获取工龄(self):return self.工龄
def 工资(self):
return 3000 + 500 * self.级别 + 50 * self.工龄
class 组长(普通员工):
最高级别 = 6
def __init__(self, 工号, 姓名, 级别, 工龄):
super().__init__(工号, 姓名, 级别, 工龄)
self.职位 = 'T'
def 工资(self):
return 4000 + 800 * self.级别 + 100 * self.工龄
class 经理(组长):
最高级别 = 3
def __init__(self, 工号, 姓名, 级别, 工龄):
super().__init__(工号, 姓名, 级别, 工龄)
self.职位 = 'M'
def 工资(self):
return 5000 + 1000 * (self.级别 + self.工龄)
class 员工管理系统:
职位顺序 = ['E', 'T', 'M']
职位名称 = {'E': '普通员工', 'T': '组长', 'M': '经理'}
职位对应类 = {'E': 普通员工, 'T': 组长, 'M': 经理}
def __init__(self):
self.员工库 = {}
self.下一个工号 = 10000
def 确认工号存在(self):
工号 = int(input("请输入工号: "))
while 工号 not in self.员工库:
工号 = int(input("该工号不存在！请重新输入: "))
return 工号
def 确认级别合法(self, 职位):
最高 = self.职位对应类[职位].最高级别
级别 = int(input(f"级别(最高{最高}级): "))
while 级别 < 1 or 级别 > 最高:
级别 = int(input(f"超出范围！请输入1-{最高}: "))
return 级别
def 升职(self, 员工):
当前索引 = self.职位顺序.index(员工.职位)
新职位 = self.职位顺序[当前索引 + 1]
新类 = self.职位对应类[新职位]
新员工 = 新类(员工.工号, 员工.姓名, 1, 员工.工龄)
self.员工库[员工.工号] = 新员工
print(f"-> 恭喜升职为{self.职位名称[新职位]}！级别重置为1级")
return 新员工
def 降职(self, 员工):
当前索引 = self.职位顺序.index(员工.职位)
新职位 = self.职位顺序[当前索引 - 1]
新类 = self.职位对应类[新职位]
最高 = 新类.最高级别
新员工 = 新类(员工.工号, 员工.姓名, 最高, 员工.工龄)
self.员工库[员工.工号] = 新员工
print(f"-> 已降为{self.职位名称[新职位]}，级别为{最高}级")
return 新员工
def 打印员工信息(self, 员工):
print(f"姓名: {员工.姓名}")
print(f"工号: {员工.工号}")
print(f"职位: {self.职位名称[员工.职位]}")
print(f"级别: {员工.级别}级")
print(f"工龄: {员工.工龄}年")
print(f"薪资: ¥{员工.工资()}")
def 录入(self):
工号 = self.下一个工号
姓名 = input("姓名: ")
print("E.普通员工T.组长M.经理")
职位 = input("职位: ").upper()
while 职位 not in self.职位对应类:
职位 = input("输入错误，请选E/T/M: ").upper()
工龄 = int(input("工龄: "))
级别 = self.确认级别合法(职位)
新员工 = self.职位对应类[职位](工号, 姓名, 级别, 工龄)
self.员工库[工号] = 新员工
self.下一个工号 += 1
print(f"\n--- 录入成功 ---")
self.打印员工信息(新员工)
print()
def 查询(self):
选择 = input("1.员工查询2.职位查询: ")
print()
if 选择 == '1':
工号 = self.确认工号存在()
print()
self.打印员工信息(self.员工库[工号])
print()
elif 选择 == '2':
print("E.普通员工T.组长M.经理")
职位 = input("查询职位: ").upper()
while 职位 not in self.职位对应类:
职位 = input("输入错误，请选E/T/M: ").upper()
名单 = []
for 工号, 员工 in self.员工库.items():
if 员工.职位 == 职位:
名单.append(f"{工号}-{员工.姓名}")
print(f"\n{self.职位名称[职位]}共{len(名单)}人:")
for 行 in 名单:
print(f"{行}")
print()
def 升级(self):
工号 = self.确认工号存在()
员工 = self.员工库[工号]
增加几级 = int(input(f"当前{员工.级别}级，要升几级: "))
新级别 = 员工.级别 + 增加几级
当前职位 = 员工.职位
最高 = self.职位对应类[当前职位].最高级别
print()
while 新级别 > 最高 and 当前职位 != 'M':
员工 = self.升职(员工)
当前职位 = 员工.职位
最高 = self.职位对应类[当前职位].最高级别
新级别 = 1 + (新级别 - 1) # 超出部分继续算
if 新级别 > 最高:
员工.级别 = 最高
print(f"(已是最高职位，级别封顶为{最高}级)")
else:
员工.级别 = 新级别
print(f"升级到{新级别}级")
print()
self.打印员工信息(员工)
print()
def 降级(self):
工号 = self.确认工号存在()
员工 = self.员工库[工号]
减少几级 = int(input(f"当前{员工.级别}级，要降几级: "))
新级别 = 员工.级别 - 减少几级
当前职位 = 员工.职位
print()
while 新级别 < 1 and 当前职位 != 'E':
员工 = self.降职(员工)
当前职位 = 员工.职位
最高 = self.职位对应类[当前职位].最高级别
新级别 = 最高 - (1 - 新级别) # 超出部分继续扣
if 新级别 < 1:
员工.级别 = 1
print(f"(已是最低职位，级别封底为1级)")
else:
员工.级别 = 新级别
print(f"降级到{新级别}级")
print()
self.打印员工信息(员工)
print()
def 界面(self):
print("=" * 30)
print(" 已进入员工管理程序！")
print("=" * 30)
选项 = 0
while 选项 != 5:
选项 = input("\n1.录入2.查询3.升级4.降级5.退出\n请选择: ")
print()
if 选项 == '1': self.录入()
elif 选项 == '2': self.查询()
elif 选项 == '3': self.升级()
elif 选项 == '4': self.降级()
elif 选项 == '5': print("退出程序，再见！")
else: print("输入有误，请选1-5")
if __name__ == '__main__':
系统 = 员工管理系统()
系统.界面()
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
Python通过方法重写和鸭子类型，使同一操作作用于不同对象时产生不同结果，从而体现多态特性。
Python 实现多态有两条路径：
依靠继承 + 方法重写：子类继承父类并重写同名方法，同一方法调用产生不同结果；
依靠鸭子类型：无需继承，只要对象拥有对应同名方法，同一操作就能适配不同对象，同样达成多态效果。
第 1 题的答案是：
多态使程序面向接口编程，而不是面向具体实现编程，从而降低代码耦合度，提高扩展性和维护性。
第 2 题的答案是：
可以称为多态。因为同一个运算符“+”作用于不同类型对象时表现出不同的行为，这属于运算符多态（运算符重载）的一种体现。
第 3 题的答案是：
当我们看到一只鸟，它走起路来像鸭子，游起泳来像鸭子，叫起来也像鸭子，那这只鸟就可以称之为鸭子。
对应编程含义
不关心对象真实属于哪个类、有没有继承关系，只看它具备的行为（方法）；只要对象拥有函数需要调用的同名方法，就可以当作符合要求的对象使用，这就是鸭子类型的核心逻辑。
第 4 题的答案是：
鸭子类型通过只关注对象是否具备所需方法，而不关注对象的具体类型，降低了模块之间的依赖关系，因此主要体现为降低耦合度。
第 5 题的答案是：
不属于，函数接收参数是一样的int类型，并没有因传入不同的对象而产生差异化的行为。
-------- 动动手 --------
请将第 0 题的代码写在下方：
class Employee:
max_grade = 10
job_name = "E"
def __init__(self, name, grade, year, uid):
self.name = name
self.job = self.job_name
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):
return 3000 + 500 * self.grade + 50 * self.year
class Teamleader(Employee):
max_grade = 6
job_name = "T"
def salary(self):
return 4000 + 800 * self.grade + 100 * self.year
class Manager(Employee):
max_grade = 3
job_name = "M"
def salary(self):
return 5000 + 1000 * (self.grade + self.year)
employees = []
next_uid = 10000
def create_employee(name, job, grade, year, uid):
if job == "E":
return Employee(name, grade, year, uid)
elif job == "T":
return Teamleader(name, grade, year, uid)
elif job == "M":
return Manager(name, grade, year, uid)
else:
return None
def get_max_grade(job):
if job == "E":
return Employee.max_grade
elif job == "T":
return Teamleader.max_grade
elif job == "M":
return Manager.max_grade
def input_job():
while True:
job = input("职位（E.普通员工;T.组长;M.经理）：").strip().upper()
if job in ["E", "T", "M"]:
return job
print("职位输入错误，请重新输入！")
def input_grade(job):
max_grade = get_max_grade(job)
while True:
try:
grade = int(input("级别："))
if 1 <= grade <= max_grade:
return grade
print(f"该职位最高级别为{max_grade}，请重新录入级别：", end="")
except ValueError:
print("级别必须输入数字，请重新输入！")
def add_employee():
global next_uid
name = input("姓名：")
job = input_job()
# 工龄容错
while True:
try:
year = int(input("工龄："))
if year >= 0:
break
print("工龄不能为负数！")
except ValueError:
print("工龄必须输入数字！")
grade = input_grade(job)
emp = create_employee(name, job, grade, year, next_uid)
employees.append(emp)
print(f"录入成功！姓名：{emp.name}，工号：{emp.uid}，薪资：{emp.salary()}")
next_uid += 1
def find_by_uid(uid):
for emp in employees:
if emp.uid == uid:
return emp
return None
def search_employee():
try:
uid = int(input("请输入工号："))
except ValueError:
print("工号必须是数字！")
return
emp = find_by_uid(uid)
if emp is None:
print("该工号不存在！")
else:
print(f"姓名：{emp.name}")
print(f"职位：{emp.job}")
print(f"级别：{emp.grade}")
print(f"工龄：{emp.year}")
print(f"薪资：{emp.salary()}")
def search_job():
job = input_job()
result =
job_text = {"E": "普通员工", "T": "组长", "M": "经理"}
if len(result) == 0:
print(f"目前公司没有{job_text}！")
else:
print(f"目前{job_text}共有 {len(result)} 人：")
for emp in result:
print(f"{emp.uid} - {emp.name}")
def search():
choice = input("1.员工查询;2.职位查询：").strip()
if choice == "1":
search_employee()
elif choice == "2":
search_job()
else:
print("输入错误！")
def promote(emp):
if emp.job == "E":
return Teamleader(emp.name, 1, emp.year, emp.uid)
elif emp.job == "T":
return Manager(emp.name, 1, emp.year, emp.uid)
else:
# 经理无法再升职，返回自身
print("当前已是最高职位经理，无法继续升职！")
return emp
def demote(emp):
if emp.job == "M":
return Teamleader(emp.name, Teamleader.max_grade, emp.year, emp.uid)
elif emp.job == "T":
return Employee(emp.name, Employee.max_grade, emp.year, emp.uid)
else:
# 普通员工无法再降职
print("当前已是最低职位普通员工，无法继续降职！")
return emp
def upgrade():
try:
uid = int(input("请输入工号："))
except ValueError:
print("工号必须是数字！")
return
emp = find_by_uid(uid)
if emp is None:
print("该工号不存在！")
return
old_salary = emp.salary()
print(f"{emp.name}，工号：{emp.uid}，当前职位：{emp.job}{emp.grade}，当前薪资：{old_salary}")
# 输入增加级数容错
try:
num = int(input("请输入需要增加的级数："))
if num <= 0:
print("增加级数必须大于0！")
return
except ValueError:
print("级数必须输入数字！")
return
# 先计算升级后理论等级，不直接修改原对象
target_grade = emp.grade + num
idx = employees.index(emp)
if target_grade > emp.max_grade:
# 溢出，升职
new_emp = promote(emp)
employees = new_emp
emp = new_emp
else:
# 未溢出，仅修改等级
emp.grade = target_grade
new_salary = emp.salary()
diff = new_salary - old_salary
print("升级成功！")
print(f"{emp.name}，工号：{emp.uid}，升级后职位：{emp.job}{emp.grade}，升级后薪资：{new_salary}(+{diff})")
def downgrade():
try:
uid = int(input("请输入工号："))
except ValueError:
print("工号必须是数字！")
return
emp = find_by_uid(uid)
if emp is None:
print("该工号不存在！")
return
old_salary = emp.salary()
print(f"{emp.name}，工号：{emp.uid}，当前职位：{emp.job}{emp.grade}，当前薪资：{old_salary}")
try:
num = int(input("请输入需要减少的级数："))
if num <= 0:
print("减少级数必须大于0！")
return
except ValueError:
print("级数必须输入数字！")
return
target_grade = emp.grade - num
idx = employees.index(emp)
if target_grade < 1:
# 低于1级，降职
new_emp = demote(emp)
employees = new_emp
emp = new_emp
else:
emp.grade = target_grade
new_salary = emp.salary()
diff = new_salary - old_salary
# 匹配截图格式，负数带括号
if diff >= 0:
diff_str = f"(+{diff})"
else:
diff_str = f"({diff})"
print("降级成功！")
print(f"{emp.name}，工号：{emp.uid}，降级后职位：{emp.job}{emp.grade}，降级后薪资：{new_salary}{diff_str}")
def main():
while True:
print("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
choice = input("请选择功能：").strip()
if choice == "1":
add_employee()
elif choice == "2":
search()
elif choice == "3":
upgrade()
elif choice == "4":
downgrade()
elif choice == "5":
print("程序退出！")
break
else:
print("输入错误，请重新输入！")
if __name__ == "__main__":
main()
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：1
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：同一方法，不同对象表现不同
第 1 题的答案是：让代码更灵活
第 2 题的答案是：可以
第 3 题的答案是：If it walks like a duck and it quacks like a duck, then it is probably a duck.
第 4 题的答案是：降低耦合度。因为它不要求对象必须属于某个特定类型
第 5 题的答案是：不是，要用默认函数
-------- 动动手 --------
请将第 0 题的代码写在下方：
class Person:
def __init__(self,uid,name,job,grade,year,salary):
self.uid=uid
self.name=name
self.job=job
self.grade=grade
self.year=year
self.salary=salary
class Menu:
def __init__(self):
self.info={}
self.next_id=10000
def register(self,name,job,age,grade):
salary=0
realgrade=grade
while(job=="M" and realgrade>3):
realgrade=int(input("该职位最高为3级，请重新输入级别："))
while(job=="T" and realgrade>6):
realgrade=int(input("该职位最高为6级，请重新输入级别："))
if(job=="E"):
salary=3000+500*realgrade+50*age
elif job=="T":
salary=4000+800*realgrade+100*age
else:
salary=5000+1000*(realgrade+age)
self.info=Person(self.next_id,name,job,realgrade,age,salary)
print(f"录入成功！姓名：{self.info.name},工号：{self.next_id},薪资：{self.info.salary}")
self.next_id+=1
def search1(self,uid):
if uid in self.info:
print(f"姓名：{self.info.name}")
print(f"职位：{self.info.job}")
print(f"级别：{self.info.grade}")
print(f"工龄：{self.info.year}")
print(f"薪资：{self.info.salary}")
else:
print("该工号不存在！")
return
def search2(self,job):
tmp=[]
tmp2=[]
for i in self.info:
if(self.info.job==job):
tmp.append(self.info.uid)
tmp2.append(self.info.name)
print(f"目前{job}共有{len(tmp)}人：")
for i in range(len(tmp)):
print(f"{tmp}--{tmp2}")
def upgrade(self,uid):
if(uid not in self.info):
print("该工号不存在！")
return
else:
print(f"{self.info.name},工号：{self.info.uid},当前职位：{self.info.job+str(self.info.grade)},当前薪资：{self.info.salary}")
level=int(input("请输入需要增加的级别:"))
self.info.grade+=level
if(self.info.job=="E" and self.info.grade>10):
self.info.job="T"
self.info.grade=1
elif(self.info.job=="T" and self.info.grade>6):
self.info.job="M"
self.info.grade=1
if(self.info.job=="E"):
newsalary=3000+500*self.info.grade+50*self.info.year
if(self.info.job=="T"):
newsalary=4000+800*self.info.grade+100*self.info.year
if(self.info.job=="M"):
newsalary=5000+1000*(self.info.grade+self.info.year)
print(f"{self.info.name},工号：{self.info.uid},当前职位：{self.info.job+str(self.info.grade)},当前薪资：{newsalary}(+{newsalary-self.info.salary})")
self.info.salary=newsalary
def downgrade(self,uid):
if(uid not in self.info):
print("该工号不存在！")
return
else:
print(f"{self.info.name},工号：{self.info.uid},当前职位：{self.info.job+str(self.info.grade)},当前薪资：{self.info.salary}")
level=int(input("请输入需要减少的级别:"))
self.info.grade-=level
if(self.info.job=="E" and self.info.grade<1):
self.info.job="E"
self.info.grade=1
elif(self.info.job=="T" and self.info.grade<1):
self.info.job="E"
self.info.grade=10
elif(self.info.job=="M" and self.info.grade<1):
self.info.job="T"
self.info.grade=6
if(self.info.job=="E"):
newsalary=3000+500*self.info.grade+50*self.info.year
if(self.info.job=="T"):
newsalary=4000+800*self.info.grade+100*self.info.year
if(self.info.job=="M"):
newsalary=5000+1000*(self.info.grade+self.info.year)
print(f"{self.info.name},工号：{self.info.uid},当前职位：{self.info.job+str(self.info.grade)},当前薪资：{newsalary}({newsalary-self.info.salary})")
self.info.salary=newsalary
menu=Menu()
query=0
while(query!=5):
query=int(input("1.录入 2.查询 3.升级 4.降级 5.退出:"))
if(query==5):
break
if(query==1):
name=input("姓名:")
job=input("职位(E.普通员工；T.组长；M.经理):")
year=int(input("工龄:"))
grade=int(input("级别:"))
menu.register(name,job,year,grade)
if(query==2):
query2=int(input("1.员工查询 2.职位查询"))
if(query2==1):
uid=int(input("请输入工号:"))
menu.search1(uid)
if(query2==2):
job=input("请输入职位(E.普通员工 T.组长 M.经理)")
menu.search2(job)
if(query==3):
uid=int(input("请输入工号"))
menu.upgrade(uid)
if(query==4):
uid=int(input("请输入工号"))
menu.downgrade(uid)
print()
print("------------------------------")
print()
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：用同一接口执行不同操作
第 2 题的答案是：可以
第 3 题的答案是：
第 4 题的答案是：增强内聚
第 5 题的答案是：算
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
基于“类继承与方法重写”
第 1 题的答案是：
可扩展性，解耦性，可读性，可替代性
第 2 题的答案是：
可以，定义是：同一接口，多种实现；相同形式，不同行为
第 3 题的答案是：
如果它走起来像鸭子，叫起来也像鸭子，那么它就是鸭子。
第 4 题的答案是：
显著降低了模块之间的耦合度（Coupling）；同时，它对内聚度（Cohesion）没有直接的破坏，甚至在一定程度上促进了高内聚。
第 5 题的答案是：
不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
1请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：