请回复您的答案^_^
-------- 问答题 --------
第 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 题的答案是：
第 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, 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(year):
return self.uid
def salary(self):
if self.job == 'E':
return 3000 + 500 * self.grade + 50 * self.year
elif self.job == 'T':
return 4000 + 800 * self.grade + 100 * self.year
else:
return 5000 + 1000 * self.grade + 1000 * self.year
# 管理类：所有功能的实现
##class Manage(PswMixin, LoggerMixin):
class Manage:
# 程序功能：录入
def Create(self, member):
uid = 10000
while uid in :
uid += 1
name = input('姓名：').strip()
job = input('职位（E.普通员工; T.组长; M.经理）：').strip()
while job not in ['E', 'T', 'M']:
job = input('请重新输入员工分类(E、T、M)：').strip()
year = int(input('工龄：').strip())
while year > 50 or year < 0:
year = int(input('请重新输入工龄：').strip())
grade = int(input('级别：').strip())
if job == 'E':
while grade > 10 or grade < 0:
grade = int(input('请重新输入级别：').strip())
elif job == 'T':
while grade > 6 or grade < 0:
grade = int(input('请重新输入级别：').strip())
else:
while grade > 3 or grade < 0:
grade = int(input('请重新输入级别：').strip())
member.append(Member(name, job, grade, year, uid))
print(f"录入成功！姓名： {member[-1].name}，工号： {member[-1].uid}，薪资：{member[-1].salary()}")
## self.log(f"开卡成功：{num} -> {uid}，时间：{rtime}\n")
# 程序功能：查询
def Lookup(self, member):
jobs = {'E':'普通员工', 'T':'组长', 'M':'经理'}
ins = input('1.员工查询;2.职位查询：').strip()
if ins == '1':
uid = int(input('请输入工号：').strip())
if uid in :
print(f'姓名：{member.name}')
print(f'职位：{member.job}')
print(f'级别：{member.grade}')
print(f'工龄：{member.year}')
print(f'薪资：{member.salary()}')
else:
print('该工号不存在！')
elif ins == '2':
job = input('职位（E.普通员工; T.组长; M.经理）：').strip()
job_reg =
print(f'目前{jobs}共有{len(job_reg)}人：')
for each in job_reg:
print(f'{each.uid} - {each.name}')
else:
print('查询指令错误！')
# 程序功能：升级
def Upgrade(self, member):
uid = int(input('请输入工号：').strip())
while uid not in :
uid = int(input('该工号不存在，请重新输入：').strip())
member_reg = member
print(f"{member_reg.name}，工号：{member_reg.uid}，当前职位：{member_reg.job + str(member_reg.grade)}，当前薪资：{member_reg.salary()}")
suma = member_reg.grade + int(input('请输入需要增加的级数：').strip())
if member_reg.job == 'E':
if suma > 10:
member_reg.job = 'T'
member_reg.grade = 1
else:
member_reg.grade = suma
elif member_reg.job == 'T':
if suma > 5:
member_reg.job = 'M'
member_reg.grade = 1
else:
member_reg.grade = suma
else:
if suma > 3:
member_reg.grade = 3
else:
member_reg.grade = suma
print('升级成功！')
print(f"{member_reg.name}，工号：{member_reg.uid}，升级后职位：{member_reg.job + str(member_reg.grade)}，升级后薪资：{member_reg.salary()}{}")
member = member_reg
# 程序功能：降级
def Downgrade(self, member):
uid = int(input('请输入工号：').strip())
while uid not in :
uid = int(input('该工号不存在，请重新输入：').strip())
member_reg = member
print(f"{member_reg.name}，工号：{member_reg.uid}，当前职位：{member_reg.job + str(member_reg.grade)}，当前薪资：{member_reg.salary()}")
suma = member_reg.grade - int(input('请输入需要减少的级数：').strip())
if member_reg.job == 'E':
if suma < 1:
member_reg.grade = 1
else:
member_reg.grade = suma
elif member_reg.job == 'T':
if suma < 1:
member_reg.job = 'E'
member_reg.grade = 10
else:
member_reg.grade = suma
else:
if suma < 1:
member_reg.job = 'T'
member_reg.grade = 6
else:
member_reg.grade = suma
print('降级成功！')
print(f"{member_reg.name}，工号：{member_reg.uid}，降级后职位：{member_reg.job + str(member_reg.grade)}，降级后薪资：{member_reg.salary()}")
member = member_reg
###主程序
##def main():
##member =
##member = []
##manage = Manage()
member = []
manage = Manage()
def main():
## member = []
## manage = Manage()
print('欢迎使用企业员工管理程序')
while True:
ins = input('\n1.录入;2.查询;3.升级;4.降级;5.退出:').strip()
if ins == '1':
manage.Create(member)
elif ins == '2':
manage.Lookup(member)
elif ins == '3':
manage.Upgrade(member)
elif ins == '4':
manage.Downgrade(member)
elif ins == '5':
print('感谢使用企业员工管理程序')
break
else:
print('请输入正确指令！')
请回复1您的答案^_^
-------- 问答题 --------
第 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 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
## 企业员工管理程序
#员工总类
class Workers:
def __init__(self,uid,name,job,year):
self.uid = uid
self.name = name
self.job = job
self.year = year
def set_grade(self):
pass
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):
pass
#普通员工
class Employee(Workers):
def set_grade(self,grade):
while grade > 10:
grade = int(input('该级别最高为10，请重新录入：'))
self.grade = grade
return self.grade
def salary(self):
self.payroll = 3000 + 500 * self.grade + 50 * self.year
return self.payroll
#组长
class Teamleader(Workers):
def set_grade(self,grade):
while grade > 6:
grade = int(input('该级别最高为6，请重新录入：'))
self.grade = grade
return self.grade
def salary(self):
self.payroll = 4000 + 800 * self.grade + 100 * self.year
return self.payroll
#经理
class Manager(Workers):
def set_grade(self,grade):
while grade > 3:
grade = int(input('该级别最高为3，请重新录入：'))
self.grade = grade
return self.grade
def salary(self):
self.payroll = 5000 + 1000 * (self.grade + self.year)
return self.payroll
#运行主程序
class Manage:
def __init__(self,data={},topuid=10000):
self.data = data
self.topuid = topuid
self.wellcom()
#导入程序
def wellcom(self):
print('欢迎使用企业员工管理程序')
while True:
ans = input("\n1.录入；2.查询；3.升级；4.降级；5.退出：")
if ans == '1':
self.create()
if ans == '2':
self.search()
if ans == '3':
self.up_grade()
if ans == '4':
self.lower_grade()
if ans == '5':
print('感谢使用企业员工管理程序')
break
#创建程序
def create(self):
uid = self.topuid
self.topuid += 1
name = input('姓名：')
job = input('职位(E.普通员工；T.组长；M.经理)：')
year = int(input('工龄：'))
if job == 'E':
worker = Employee(uid,name,'E',year)
if job == 'T':
worker = Teamleader(uid,name,'T',year)
if job == 'M':
worker = Manager(uid,name,'M',year)
worker.set_grade(int(input('级别：')))
self.data = worker
print(f'录入成功！姓名：{worker.name}，工号{worker.uid}，薪资：{worker.salary()}')
#查询程序
def search(self):
worker_list = []
ans = input('1.员工查询；2.职位查询：')
#员工查询
if ans == '1':
uid = input('请输入工号：')
if not self.data.get(uid,False):
print('该工号不存在!')
else:
worker = self.data
print(f'姓名：{worker.name}')
print(f'职位：{worker.job}')
print(f'级别：{worker.grade}')
print(f'工龄：{worker.year}')
print(f'薪资：{worker.payroll}')
#职位查询
if ans == '2':
job = input('职位(E.普通员工；T.组长；M.经理)：')
job_name = ('普通员工' if job == 'E' else
'组长' if job == 'T' else
'经理' if job == 'M' else None)
for i in self.data:
if self.data.job == job:
worker_list.append(self.data)
if worker_list == []:
print(f'目前公司没有{job_name}')
else:
print(f'目前{job_name}共有{len(worker_list)}人：')
for i in worker_list:
print(f'{i.uid} - {i.name}')
#升降级判断
def re_grade(self,worker,num):
grade = worker.grade
if worker.job == 'T':
grade += 10
if worker.job == 'M':
grade += 16
while grade + num > 19:
num = int(input('超过最高级别，请重新输入：'))
while grade + num < 0:
num = int(input('低于最低级别，请重新输入：'))
grade = grade + num
if 0 < grade <= 10:
new_worker = Employee(worker.uid,worker.name,'E',worker.year)
new_worker.set_grade(grade)
if 10 < grade <= 16:
new_worker = Teamleader(worker.uid,worker.name,'T',worker.year)
new_worker.set_grade(grade - 10)
if 16 < grade <= 19:
new_worker = Manager(worker.uid,worker.name,'M',worker.year)
new_worker.set_grade(grade - 16)
return new_worker
#升级程序
def up_grade(self):
uid = input('请输入工号：')
if not self.data.get(uid,False):
print('该工号不存在!')
else:
worker = self.data
print(f'{worker.name}，工号：{uid}，当前职位：{worker.job + str(worker.grade)}，当前薪资{worker.payroll}')
num = int(input('请输入需要增加的级数：'))
new_worker = self.re_grade(worker,num)
self.data = new_worker
print('升级成功！')
print(f'{new_worker.name}，工号：{new_worker.uid}，升级后职位：{new_worker.job+str(new_worker.grade)}，升级后薪资：{new_worker.salary()}（+{str(new_worker.payroll - worker.payroll)}）')
#降级程序
def lower_grade(self):
uid = input('请输入工号：')
if not self.data.get(uid,False):
print('该工号不存在!')
else:
worker = self.data
print(f'{worker.name}，工号：{uid}，当前职位：{worker.job + str(worker.grade)}，当前薪资{worker.payroll}')
num = - int(input('请输入需要降低的级数：'))
new_worker = self.re_grade(worker,num)
self.data = new_worker
print('降级成功！')
print(f'{new_worker.name}，工号：{new_worker.uid}，降级级后职位：{new_worker.job+str(new_worker.grade)}，降级后薪资：{new_worker.salary()}（{str(new_worker.payroll - worker.payroll)}）')
m = Manage()
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
根据传入对象的不同，返回相对应的结果
第 1 题的答案是：
简洁明了，方便快捷
第 2 题的答案是：
可以
第 3 题的答案是：
不知道
第 4 题的答案是：
增强内聚
第 5 题的答案是：
不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：## 企业员工管理程序
#员工总类
class Workers:
def __init__(self,uid,name,job,year):
self.uid = uid
self.name = name
self.job = job
self.year = year
def set_grade(self):
pass
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):
pass
#普通员工
class Employee(Workers):
def set_grade(self,grade):
while grade > 10:
grade = int(input('该级别最高为10，请重新录入：'))
self.grade = grade
return self.grade
def salary(self):
self.payroll = 3000 + 500 * self.grade + 50 * self.year
return self.payroll
#组长
class Teamleader(Workers):
def set_grade(self,grade):
while grade > 6:
grade = int(input('该级别最高为6，请重新录入：'))
self.grade = grade
return self.grade
def salary(self):
self.payroll = 4000 + 800 * self.grade + 100 * self.year
return self.payroll
#经理
class Manager(Workers):
def set_grade(self,grade):
while grade > 3:
grade = int(input('该级别最高为3，请重新录入：'))
self.grade = grade
return self.grade
def salary(self):
self.payroll = 5000 + 1000 * (self.grade + self.year)
return self.payroll
#运行主程序
class Manage:
def __init__(self,data={},topuid=10000):
self.data = data
self.topuid = topuid
self.wellcom()
#导入程序
def wellcom(self):
print('欢迎使用企业员工管理程序')
while True:
ans = input("\n1.录入；2.查询；3.升级；4.降级；5.退出：")
if ans == '1':
self.create()
if ans == '2':
self.search()
if ans == '3':
self.up_grade()
if ans == '4':
self.lower_grade()
if ans == '5':
print('感谢使用企业员工管理程序')
break
#创建程序
def create(self):
uid = self.topuid
self.topuid += 1
name = input('姓名：')
job = input('职位(E.普通员工；T.组长；M.经理)：')
year = int(input('工龄：'))
if job == 'E':
worker = Employee(uid,name,'E',year)
if job == 'T':
worker = Teamleader(uid,name,'T',year)
if job == 'M':
worker = Manager(uid,name,'M',year)
worker.set_grade(int(input('级别：')))
self.data = worker
print(f'录入成功！姓名：{worker.name}，工号{worker.uid}，薪资：{worker.salary()}')
#查询程序
def search(self):
worker_list = []
ans = input('1.员工查询；2.职位查询：')
#员工查询
if ans == '1':
uid = input('请输入工号：')
if not self.data.get(uid,False):
print('该工号不存在!')
else:
worker = self.data
print(f'姓名：{worker.name}')
print(f'职位：{worker.job}')
print(f'级别：{worker.grade}')
print(f'工龄：{worker.year}')
print(f'薪资：{worker.payroll}')
#职位查询
if ans == '2':
job = input('职位(E.普通员工；T.组长；M.经理)：')
job_name = ('普通员工' if job == 'E' else
'组长' if job == 'T' else
'经理' if job == 'M' else None)
for i in self.data:
if self.data.job == job:
worker_list.append(self.data)
if worker_list == []:
print(f'目前公司没有{job_name}')
else:
print(f'目前{job_name}共有{len(worker_list)}人：')
for i in worker_list:
print(f'{i.uid} - {i.name}')
#升降级判断
def re_grade(self,worker,num):
grade = worker.grade
if worker.job == 'T':
grade += 10
if worker.job == 'M':
grade += 16
while grade + num > 19:
num = int(input('超过最高级别，请重新输入：'))
while grade + num < 0:
num = int(input('低于最低级别，请重新输入：'))
grade = grade + num
if 0 < grade <= 10:
new_worker = Employee(worker.uid,worker.name,'E',worker.year)
new_worker.set_grade(grade)
if 10 < grade <= 16:
new_worker = Teamleader(worker.uid,worker.name,'T',worker.year)
new_worker.set_grade(grade - 10)
if 16 < grade <= 19:
new_worker = Manager(worker.uid,worker.name,'M',worker.year)
new_worker.set_grade(grade - 16)
#升级程序
def up_grade(self):
uid = input('请输入工号：')
if not self.data.get(uid,False):
print('该工号不存在!')
else:
worker = self.data
print(f'{worker.name}，工号：{uid}，当前职位：{worker.job + str(worker.grade)}，当前薪资{worker.payroll}')
num = int(input('请输入需要增加的级数'))
new_worker = self.re_grade(worker,num)
self.data = new_worker
print('升级成功！')
print(f'{new_worker.name}，工号：{new_worker.uid}，升级后职位：{new_worker.job+str(new_worker.grade)}，升级后薪资：{new_worker.salary()}（+{str(new_worker.payroll - worker.payroll)}）')
#降级程序
def lower_grade(self):
uid = input('请输入工号：')
if not self.data.get(uid,False):
print('该工号不存在!')
else:
worker = self.data
print(f'{worker.name}，工号：{uid}，当前职位：{worker.job + str(worker.grade)}，当前薪资{worker.payroll}')
num = - int(input('请输入需要降低的级数'))
new_worker = self.re_grade(worker,num)
self.data = new_worker
print('降级成功！')
print(f'{new_worker.name}，工号：{new_worker.uid}，降级级后职位：{new_worker.job+str(new_worker.grade)}，降级后薪资：{new_worker.salary()}（{str(new_worker.payroll - worker.payroll)}）')
m = Manage()
请回复您的答案^_^
-------- 问答题 --------
第 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 题的代码写在下方：
# 63_企业员工管理程序 #
# 员工属性
class Staff:
def __init__(self, name, job, grade, year, uid, salary):
self.name = name
self.job = job
self.grade = grade
self.year = year
self.uid = uid
self.salary = salary
# 程序功能
class Function:
def __init__(self):
self.staffs = {}
self.staffs_E = {}
self.staffs_T = {}
self.staffs_M = {}
self.uid = 10000
# 选择功能
def select_function(self):
ins = ''
while ins != '5':
ins = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
if ins == '1':
self.enter_information()
elif ins == '2':
self.search_information()
elif ins == '3':
self.upgrade_level()
elif ins == '4':
self.downgrade_level()
print()
# 职位判断
def job_isright(self):
job = input('职位（E.普通员工; T.组长；M.经理）：')
while job == 'E' or job == 'T' or job == 'M':
return job
else:
job = input('职位输入错误，请重新输入（E.普通员工; T.组长；M.经理）：')
# 级别判断
def grade_judgment(self, job):
grade = int(input('级别：'))
while True:
if job == 'E':
if 0 < grade <= 10 :
return grade
else:
grade = int(input('该职位最高级别为10，请重新录入级别：'))
continue
if job == 'T':
if 0 < grade <= 6:
return grade
else:
grade = int(input('该职位最高级别为6，请重新录入级别：'))
continue
if job == 'M':
if 0 < grade <= 3:
return grade
else:
grade = int(input('该职位最高级别为3，请重新录入级别：'))
# 工号判断
def uid_judgment(self):
uid = int(input('请输入工号：'))
if self.staffs.get(uid):
return uid
else:
return False
# 统计工资
def salary_calculation(self, job, grade, year):
if job == 'E':
salary = 3000 + 500 * grade + 50 * year
elif job == 'T':
salary = 4000 + 800 * grade + 100 * year
elif job == "M":
salary = 5000 + 1000 * (grade + year)
return salary
# 员工分职位录入
def enter_information_job(self, job, staff):
if job == "E":
self.staffs_E = staff
elif job == "T":
self.staffs_T = staff
elif job == "M":
self.staffs_M = staff
# 录入信息
def enter_information(self):
name = input("姓名：")
job = self.job_isright()
year = int(input('工龄：'))
grade = self.grade_judgment(job)
salary = self.salary_calculation(job, grade, year)
staff = Staff(name, job, grade, year, self.uid, salary)
self.staffs = staff
self.enter_information_job(job, staff)
print(f'录入成功！姓名：{name}，工号：{self.uid}, 薪资：{salary}')
self.uid += 1
# 查询信息
def search_information(self):
search = input('1.员工查询； 2.职位查询：')
if search == "1":
self.search_information_staff()
elif search == '2':
self.search_information_job()
else:
print('输入错误！，请重新输入')
self.search_information()
# 查询信息_员工查询
def search_information_staff(self):
uid = self.uid_judgment()
if uid:
print(f'姓名：{self.staffs.name}')
print(f'职位：{self.staffs.job}')
print(f'级别：{self.staffs.grade}')
print(f'工龄：{self.staffs.year}')
print(f'薪资：{self.staffs.salary}')
else:
print('该工号不存在')
# 查询信息_职位查询
def search_information_job(self):
job = input('职位（E.普通员工；T.组长；M.经理）：')
if job == "E":
self.search_information_job_enumeration(self.staffs_E, "普通员工")
elif job == "T":
self.search_information_job_enumeration(self.staffs_T, "组长")
elif job == "M":
self.search_information_job_enumeration(self.staffs_M, "经理")
else:
print('输入错误！')
self.search_information_job()
# 职位职员枚举
def search_information_job_enumeration(self, staffs, k):
if len(staffs) == 0:
print(f"目前公司没有{k}")
else:
print(f"目前{k}共有{len(staffs)}人：")
for i in staffs.values():
print(f'{i.uid} - {i.name}')
# 获取信息_服务升降级
def get_information_grade(self):
uid = self.uid_judgment()
p = self.staffs
print(f'{p.name}, 工号：{p.uid}, 当前职位：{p.job}{p.grade}, 当前薪资：{p.salary}')
return p
# 升级
def upgrade_level(self):
p = self.get_information_grade()
add_grade = int(input('请输入需要增加的级数：'))
p.grade = self.up_level(p, add_grade)
new_salary = self.salary_calculation(p.job, p.grade, p.year)
print('升级成功！')
print(f'{p.name}, 工号：{p.uid}, 当前职位：{p.job}{p.grade}, 升级后薪资：{new_salary}(+{new_salary-p.salary})')
p.salary = new_salary
# 判断升阶
def up_level(self, p, grade):
new_grade = p.grade + grade
if p.job == "E" and 1 <= new_grade <= 10 or p.job == "T" and 1 <= new_grade <= 6 or p.job == "M" and 1 <= new_grade <= 3:
return new_grade
elif p.job == "M" and new_grade > 3:
print("升级超过最高等级！")
new_add_grade = input('请输入需要增加的级数：')
self.up_level(p, new_add_grade)
else:
return self.up_adjust_job(p)
# 升阶后调整职位
def up_adjust_job(self, p):
if p.job == 'E':
p.job = "T"
self.staffs_T = self.staffs_E.pop(p.uid)
elif p.job == 'T':
p.job = "M"
self.staffs_M = self.staffs_T.pop(p.uid)
return 1
# 降级
def downgrade_level(self):
p = self.get_information_grade()
reduce_grade = int(input('请输入需要减少的级数：'))
p.grade = self.down_level(p, reduce_grade)
new_salary = self.salary_calculation(p.job, p.grade, p.year)
print('降级成功！')
print(f'{p.name}, 工号：{p.uid}, 当前职位：{p.job}{p.grade}, 降级后薪资：{new_salary}(-{p.salary-new_salary})')
p.salary = new_salary
# 判断降阶
def down_level(self, p, grade):
new_grade = p.grade - grade
if p.job == "E" and 1 <= new_grade <= 10 or p.job == "T" and 1 <= new_grade <= 6 or p.job == "M" and 1 <= new_grade <= 3:
return new_grade
elif p.job == "E" and new_grade < 1:
print("降级超过最低等级！")
new_reduce_grade = input('请输入需要减少的级数：')
self.down_level(p, new_reduce_grade)
else:
return self.down_adjust_job(p)
# 降级后调整职位
def down_adjust_job(self, p):
if p.job == 'M':
p.job = "T"
self.staffs_T = self.staffs_M.pop(p.uid)
return 6
elif p.job == 'T':
p.job = "E"
self.staffs_E = self.staffs_T.pop(p.uid)
return 10
def main():
st = Function()
st.select_function()
请回复您的答案^_^
-------- 问答题 --------
第 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 题的代码写在下方：
1请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：