请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
一个固定的函数可以实现不同的功能
第 1 题的答案是：
灵活
第 2 题的答案是：
可以
第 3 题的答案是：
第 4 题的答案是：
高内聚
第 5 题的答案是：
是的
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 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 题的代码写在下方：
class Employee:
employee_beginsno = 10000
employee_lastsno = 0
def __init__(self, name, job, year, grade, uid=0):
self.name = name
self.job = job
self.grade = grade
self.year = year
if uid != 0:
self.uid = uid
else:
if Employee.employee_lastsno == 0:
self.uid = Employee.employee_beginsno
else:
self.uid = Employee.employee_lastsno + 1
Employee.employee_lastsno = self.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 + self.grade * 500 + self.year * 50
class Teamleader(Employee):
def __init__(self, name, job, year, grade, uid=0):
super().__init__(name, job, year, grade, uid)
def salary(self):
return 4000 + self.grade * 800 + self.year * 100
class Manager(Employee):
def __init__(self, name, job, year, grade, uid=0):
super().__init__(name, job, year, grade, uid)
def salary(self):
return 5000 + self.grade * 1000 + self.year * 1000
class EmployeeManage:
employee_list = []
teamleader_list = []
manager_list = []
max_try_times = 3
# 职位级别,E-普通员工：10个级别;T-组长：6个级别;M-经理：3个级别
job_grade = {"E": 10, "T": 6, "M": 3}
def welcome(self):
print("欢迎使用鱼C企业员工管理系统")
while True:
oper_type = input("1.录入;2.查询;3.升级;4.降级;5.退出：").strip()
if oper_type == "1":
self.employee_lr()
elif oper_type == "2":
self.employee_cx()
elif oper_type == "3":
self.employee_sj()
elif oper_type == "4":
self.employee_jj()
elif oper_type == "5":
print("感谢使用鱼C企业员工管理系统")
break
else:
print("请输入正确的操作类型")
def employee_lr(self):
error_times = 0
name = input("姓名：").strip()
job = ""
while error_times < self.max_try_times:
job = input("职位(E.普通员工;T.组长;M.经理)：").strip()
if job not in ["E", "T", "M"]:
error_times += 1
print("请输入正确的职位类型")
else:
break
else:
print("输入错误次数过多，请重新输入")
return
error_times = 0
year = 0
while error_times < self.max_try_times:
v_year = input("工龄：").strip()
if v_year.isdigit() == False or int(v_year) < 0 or int(v_year) > 100:
error_times += 1
print("请输入正确的工龄")
else:
year = int(v_year)
break
else:
print("输入错误次数过多，请重新输入")
return
error_times = 0
grade = 0
while error_times < self.max_try_times:
v_grade = input("级别：").strip()
if (
v_grade.isdigit() == False
or int(v_grade) < 0
or int(v_grade) > self.job_grade
):
error_times += 1
print(f"该职位最高级别为{self.job_grade}，请重新输入")
else:
grade = int(v_grade)
break
else:
print("输入错误次数过多，请重新输入")
return
employee = None
if job == "E":
employee = Employee(name, job, year, grade)
self.employee_list.append(employee)
elif job == "T":
employee = Teamleader(name, job, year, grade)
self.teamleader_list.append(employee)
elif job == "M":
employee = Manager(name, job, year, grade)
self.manager_list.append(employee)
if employee:
print(
f"录入成功！姓名：{name}，工号：{employee.get_uid()}，薪资：{employee.salary()}"
)
def employee_cx(self):
error_times = 0
while error_times < self.max_try_times:
cx_type = input("1.员工查询;2.职位查询：").strip()
if cx_type == "1":
id = input("员工编号：").strip()
employee = self.exist_employee(id)
if employee:
self.print_employee(employee)
break
else:
print("该工号不存在！")
elif cx_type == "2":
job = input("职位(E.普通员工;T.组长;M.经理)：").strip()
self.job_employee(job)
break
else:
error_times += 1
print("请输入正确的查询类型")
def employee_sj(self):
id = input("请输入工号：").strip()
employee = self.exist_employee(id)
if not employee:
print("该工号不存在！")
return
print(
f"姓名：{employee.get_name()},工号：{employee.get_uid()}，职位：{employee.get_job()}{employee.get_grade()}，当前薪资：{employee.salary()}"
)
job = employee.get_job()
grade = employee.get_grade()
add_grade = input("请输入要增加的级数：").strip()
if (
add_grade.isdigit() == False
or int(add_grade) < 0
or int(add_grade) + employee.get_grade() > 19
):
print("请输入正确的级别")
return
# 主要超过当前职位级别，则升级为下一个职位，并且级别设置为当前职位级别1
new_employee = None
old_salary = employee.salary()
sj_flag = True
if job == "E":
if grade + int(add_grade) > self.job_grade["E"]:
new_job = "T"
new_grade = 1
new_employee = Teamleader(
employee.get_name(),
new_job,
employee.get_year(),
new_grade,
employee.get_uid(),
)
self.teamleader_list.append(new_employee)
self.employee_list.remove(employee)
else:
employee.grade += int(add_grade)
elif job == "T":
if grade + int(add_grade) > self.job_grade["T"]:
new_job = "M"
new_grade = 1
new_employee = Manager(
employee.get_name(),
new_job,
employee.get_year(),
new_grade,
employee.get_uid(),
)
self.manager_list.append(new_employee)
self.teamleader_list.remove(employee)
else:
employee.grade += int(add_grade)
elif job == "M":
if grade + int(add_grade) > self.job_grade["M"]:
sj_flag = False
print("无法升级")
else:
employee.grade += int(add_grade)
if sj_flag:
print("升级成功！")
add_salary = new_employee.salary() - old_salary
print(
f"姓名：{new_employee.get_name()}，工号：{new_employee.get_uid()}，职位：{new_employee.get_job()}{new_employee.get_grade()}，当前薪资：{new_employee.salary()}(+{add_salary})"
)
def employee_jj(self):
id = input("请输入工号：").strip()
employee = self.exist_employee(id)
if not employee:
print("该工号不存在！")
return
print(
f"姓名：{employee.get_name()},工号：{employee.get_uid()}，职位：{employee.get_job()}{employee.get_grade()}，当前薪资：{employee.salary()}"
)
job = employee.get_job()
grade = employee.get_grade()
add_grade = input("请输入要减少的级数：").strip()
if add_grade.isdigit() == False or int(add_grade) < 0:
print("请输入正确的级别")
return
# 主要小于当前职位的最低级别，则降级为下一个职位的最高级别
new_employee = None
old_salary = employee.salary()
jj_flag = True
if job == "E":
if grade - int(add_grade) <= 0:
employee.grade = 1
else:
employee.grade = grade - int(add_grade)
elif job == "T":
if grade - int(add_grade) <= 0:
new_job = "E"
new_grade = 10
new_employee = Employee(
employee.get_name(),
new_job,
employee.get_year(),
new_grade,
employee.get_uid(),
)
self.employee_list.append(new_employee)
self.teamleader_list.remove(employee)
else:
employee.grade -= int(add_grade)
elif job == "M":
if grade - int(add_grade) <= 0:
new_job = "T"
new_grade = 6
new_employee = Teamleader(
employee.get_name(),
new_job,
employee.get_year(),
new_grade,
employee.get_uid(),
)
self.teamleader_list.append(new_employee)
self.manager_list.remove(employee)
else:
employee.grade -= int(add_grade)
if jj_flag:
print("降级成功！")
add_salary = new_employee.salary() - old_salary
print(
f"姓名：{new_employee.get_name()}，工号：{new_employee.get_uid()}，职位：{new_employee.get_job()}{new_employee.get_grade()}，当前薪资：{new_employee.salary()}({add_salary})"
)
def exist_employee(self, id):
if id.isdigit() == False:
return None
for employee in self.employee_list:
if employee.get_uid() == int(id):
return employee
for employee in self.teamleader_list:
if employee.get_uid() == int(id):
return employee
for employee in self.manager_list:
if employee.get_uid() == int(id):
return employee
return None
def print_employee(self, employee):
print(
f"姓名：{employee.get_name()}",
f"职位：{employee.get_job()}",
f"级别：{employee.get_grade()}",
f"工龄：{employee.get_year()}",
f"薪资：{employee.salary()}",
sep="\n",
)
def job_employee(self, job):
if job == "E":
if len(self.employee_list) == 0:
print("目前公司没有普通员工")
return
print(f"目前普通员工有 {len(self.employee_list)} 人：")
for employee in self.employee_list:
print(f"{employee.get_uid()} - {employee.get_name()}")
elif job == "T":
if len(self.teamleader_list) == 0:
print("目前公司没有组长")
return
print(f"目前组长有 {len(self.teamleader_list)} 人：")
for employee in self.teamleader_list:
print(f"{employee.get_uid()} - {employee.get_name()}")
elif job == "M":
if len(self.manager_list) == 0:
print("目前公司没有经理")
return
print(f"目前经理有 {len(self.manager_list)} 人：")
for employee in self.manager_list:
print(f"{employee.get_uid()} - {employee.get_name()}")
else:
print("请输入正确的职位")
def main():
manage = EmployeeManage()
manage.welcome()
main()
请回复您的答案^_^
-------- 问答题 --------
第 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 题的代码写在下方：
LEVEL_SEQ = {'E':,'T':,'M':}
current_uid = 10000
staff = []
class People:
__slots__ = ['_name','_job','_grade','_year','_uid']
def __init__(self):
self._name = input("姓名：")
self._job = input("职位（E.普通员工；T.组长；M.经理）：")
while True: #确保级别输入正确
self._grade = int(input("级别："))
if self._grade > LEVEL_SEQ[-1]:
self._grade = input(f"级别输入错误，{self._job}级别最高为{LEVEL_SEQ[-1]}级，请重新输入级别：")
else:
break
self._year =int(input("工龄："))
global current_uid
self._uid = current_uid
current_uid += 1
def get_uid(self):
return f"工号：{self._uid}"
def get_name(self):
return f"名字：{self._name}"
def get_job(self):
return f"职位：{self._job}"
def get_grade(self):
return f"级别：{self._grade}"
def get_year(self):
return f"工龄：{self._year}"
def salary(self):
if self._job == 'E':
return 3000 + int(self._grade) * 500 + int(self._year) * 50
elif self._job == 'T':
return 4000 + int(self._grade) * 800 + int(self._year) * 100
elif self._job == 'M':
return 5000 + int(self._grade) * 1000 + int(self._year) * 1000
while True:
i = int(input("1.录入；2.查询；3.升级；4.降级；5.退出"))
if i == 5:
break
elif i == 1:
staff.append(People())
print(f"录入成功！姓名：{staff[-1]._name}，工号：{staff[-1]._uid}，薪资：{staff[-1].salary()}")
elif i == 3:
inquiry_id = int(input("请输入工号："))
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
1
请回复您的答案^_^
-----
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：同一个函数根据不同的参数返回不同的结果
第 1 题的答案是：调用时不需要区分对象
第 2 题的答案是：可以
第 3 题的答案是：不知道
第 4 题的答案是：降低了耦合度
第 5 题的答案是：不是
-------- 动动手 --------
请将第 0 题的代码写在下方：
#普通员工类
class Employee:
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 get_salary(self):
return 3000+500*self.get_grade()+50*self.get_year()
#组长类
class Teamleader(Employee):
def get_salary(self):
return 4000+800*self.get_grade()+100*self.get_year()
#经理类
class Manager(Employee):
def get_salary(self):
return 5000+1000*(self.get_grade()+self.get_year())
#功能组件
class EmployeeMixin:
#检查工号
def is_exist(self,employees):
uid=int(input("请输入工号："))
if employees.get(uid):
return uid
else:
return False
#职位对应的最高级别
def grade_total(self,job):
if job=='E':
maxlevel=10
if job=='T':
maxlevel=6
if job=='M':
maxlevel=3
return maxlevel
#统计不同职位员工
def type_count(self,employees):
counts=0
result={}
job=input("职位（E.普通员工;T.组长;M.经理）：")
t={'E':'普通员工','T':'组长','M':'经理'}
for k,v in employees.items():
if v.job==job:
counts+=1
result=v
if counts==0:
print(f"目前公司没有{t}！")
else:
print(f"目前{t}共有 {counts} 人:")
return result
class Admin(EmployeeMixin):
def __init__(self):
self.employees={}
self.uid=10000
def welcome(self):
ins=0
while ins!='5':
ins=input("1.录入；2.查询；3.升级；4.降级；5.退出：")
if ins=='1':
self.add()
if ins=='2':
self.view()
if ins=='3':
self.upgrade()
if ins=='4':
self.demote()
#实例化不同类型的员工
def employee_type(self,name,job,grade,year,uid):
if job=='E':
return Employee(name,job,grade,year,uid)
if job=='T':
return Teamleader(name,job,grade,year,uid)
if job=='M':
return Manager(name,job,grade,year,uid)
#程序功能：信息录入
def add(self):
name=input("姓名：")
job=input("职位（E.普通员工;T.组长;M.经理）：")
year=int(input("工龄："))
grade=int(input("级别："))
maxlevel=self.grade_total(job)
while grade>maxlevel:
grade=int(input(f"该职位为高级别为{maxlevel}，请重新录入级别："))
employee=self.employee_type(name,job,grade,year,self.uid)
self.employees=employee
print(f"录入成功！姓名：{name}，工号：{self.uid}，薪资：{self.employees.get_salary()}\n")
self.uid+=1
#程序功能：查询
def view(self):
t=input("1.员工查询;2.职位查询：")
if t=='1':
uid=self.is_exist(self.employees)
if uid:
print("姓名：",self.employees.get_name())
print("职位：",self.employees.get_job())
print("级别：",self.employees.get_grade())
print("工龄：",self.employees.get_year())
print("薪资：",self.employees.get_salary())
print()
else:
print("该工号不存在！\n")
if t=='2':
people=self.type_count(self.employees)
for k,v in people.items():
print(f"{k} - {v.name}")
print()
#程序功能：升级
def upgrade(self):
m=['E','T','M']
uid=self.is_exist(self.employees)
if uid:
name=self.employees.get_name()
job=self.employees.get_job()
grade=self.employees.get_grade()
year=self.employees.get_year()
salary=self.employees.get_salary()
print(f"{name}，工号：{uid}，当前职位：{job}{grade}，当前薪资：{salary}")
t=int(input("请输入需要增加的级数："))
maxlevel=self.grade_total(job)
if grade+t>maxlevel:
i=m.index(job)
if i!=len(m)-1:
job=m
grade=1
employee=self.employee_type(name,job,grade,year,uid)
self.employees=employee
print("升级成功！")
new_salary=self.employees.get_salary()
print(f"{name}，工号：{uid}，升级后职位：{job}{grade}，升级后薪资：{new_salary}(+{new_salary-salary})\n")
else:
grade=maxlevel
self.employees.grade=grade
print("已是最高级别！\n")
print(f"{name}，工号：{uid}，增加级数后职位：{job}{grade}")
else:
self.employees.grade=grade
print("未升级\n")
print(f"{name}，工号：{uid}，增加级数后职位：{job}{grade}")
else:
print("该工号不存在！\n")
#程序功能：降级
def demote(self):
m=['E','T','M']
uid=self.is_exist(self.employees)
if uid:
name=self.employees.get_name()
job=self.employees.get_job()
grade=self.employees.get_grade()
year=self.employees.get_year()
salary=self.employees.get_salary()
print(f"{name}，工号：{uid}，当前职位：{job}{grade}，当前薪资：{salary}")
t=int(input("请输入需要减少的级数："))
if grade-t<=0:
i=m.index(job)
if i!=0:
job=m
grade=self.grade_total(job)
employee=self.employee_type(name,job,grade,year,uid)
self.employees=employee
print("降级成功！")
new_salary=self.employees.get_salary()
print(f"{name}，工号：{uid}，降级后职位：{job}{grade}，升级后薪资：{new_salary}({new_salary-salary})\n")
else:
grade=1
self.employees.grade=grade
print("已是最低级别！\n")
print(f"{name}，工号：{uid}，减少级数后职位：{job}{grade-t}")
else:
self.employees.grade=grade-t
print("未降级\n")
print(f"{name}，工号：{uid}，减少级数后职位：{job}{grade-t}")
else:
print("该工号不存在！\n")
def main():
a=Admin()
a.welcome()
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
调用相同函数，创建不同对象
第 1 题的答案是：
减少重复代码
第 2 题的答案是：
可以
第 3 题的答案是：
第 4 题的答案是：
增强了内聚
第 5 题的答案是：
不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
可以
第 3 题的答案是：
如果它看起来像鸭子，游起来像鸭子，那么它就是鸭子
第 4 题的答案是：
降低耦合度
第 5 题的答案是：
是
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：1
第 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
class Manage:
def __init__(self):
self.members = {}
self.uid = 10000
#员工方法
def salary(self, job):
#员工录入
def create_member(self):
name = input('姓名: ')
job = input('职位 (E.普通员工;T.组长;M.经理) : ')
year = int(input('工龄: '))
grade = int(input('级别: '))
member = Member(name, job, grade, year, self.uid)
self.members = member
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：从基础的+和*，再到类
第 1 题的答案是：可以实现不同类型的运算
第 2 题的答案是：可以
第 3 题的答案是：不知道
第 4 题的答案是：降低了耦合度
第 5 题的答案是：不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：