第063讲：类和对象（VI） | 课后测试题及答案,《零基础入门学习Python》【最新版】,Python交流,鱼C论坛

huayangshihan 发表于 2026-4-11 17:41:37

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

zzj375100270 发表于 2026-4-8 16:40:15

请回复您的答案^_^

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

第 0 题的答案是：重写

第 1 题的答案是：更灵活

第 2 题的答案是：可以

第 3 题的答案是：

第 4 题的答案是：内聚

第 5 题的答案是：属于

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

请将第 0 题的代码写在下方：
class Staff:
def __init__(self, uid):
   self.uid = uid
   self.name = ""
   self.job = ""
   self.grade = 0
   self.year = 0
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 self.salary()
def get_level(self):
   return self.job + str(self.grade)
def salary(self):
   pass

class Employee(Staff):
def __init__(self, uid):
   super().__init__(uid)
   self.job = "E"
def salary(self):
   return 3000 + self.grade * 500 + self.year * 50

class Teamleader(Staff):
def __init__(self, uid):
   super().__init__(uid)
   self.job = "T"
def salary(self):
   return 4000 + self.grade * 800 + self.year * 100

class Manager(Staff):
def __init__(self, uid):
   super().__init__(uid)
   self.job = "M"
def salary(self):
   return 5000 + 1000 * (self.grade + self.year)

class Management:
def __init__(self):
   self.staffs = []
   self.uid = 10000

def add_staff(self):
   name = input("姓名：")
   if not name:
         print("姓名不能为空！")
         return

   job = input("职位（E.普通员工;T.组长;M.经理）：")
   if job not in ["E", "T", "M"]:
         print("职位输入错误！")
         return

   if job == "E":
         staff = Employee(self.uid)
   elif job == "T":
         staff = Teamleader(self.uid)
   else:
         staff = Manager(self.uid)

   staff.name = name

   while True:
         try:
            year = int(input("工龄："))
            if year < 0:
               print("工龄不能为负数！")
               continue
            break
         except ValueError:
            print("请输入正确的数字！")
   staff.year = year

   job_grade_max = {"E": 10, "T": 6, "M": 3}
   while True:
         try:
            grade = int(input("级别："))
            if grade < 1 or grade > job_grade_max:
               print(f"级别输入错误！{job_grade_max}级为最高级别")
               continue
            break
         except ValueError:
            print("请输入正确的数字！")
   staff.grade = grade

   self.staffs.append(staff)
   self.uid += 1
   print(f"录入成功！姓名：{staff.name}，工号：{self.uid-1}，薪资：{staff.get_salary()}")

def staff_search(self):
   while True:
         try:
            uid = int(input("请输入工号："))
            break
         except ValueError:
            print("请输入正确的数字！")

   found = False
   for staff in self.staffs:
         if staff.get_uid() == uid:
            print(f"姓名：{staff.get_name()}")
            print(f"职位：{staff.get_job()}")
            print(f"级别：{staff.get_grade()}")
            print(f"工龄：{staff.get_year()}")
            print(f"薪资：{staff.get_salary()}")
            found = True
            break
   if not found:
         print("该工号不存在！")
         return

def job_search(self):
   level_lst = {"E":"普通员工","T":"组长","M":"经理"}
   job = input("职位（E.普通员工;T.组长;M.经理）：")
   if job not in level_lst:
         print("职位输入错误！")
         return

   staff_lst = []
   staff_count = 0
   for staff in self.staffs:
         if staff.get_job() == job:
            staff_lst.append(staff)
            staff_count += 1
   if staff_count == 0:
         print(f"目前公司没有{level_lst}！")
         return
   else:
         print(f"目前{level_lst}共有{staff_count}人：")
         for staff in staff_lst:
            print(f"{staff.uid} - {staff.name}")

def search(self):
   choice = input("1.员工查询;2.职位查询：")
   if choice == "1":
         self.staff_search()
   elif choice == "2":
         self.job_search()
   else:
         print("查询类型输入错误！")
         return

def level_up(self):
   while True:
         try:
            uid = int(input("请输入工号："))
            break
         except ValueError:
            print("请输入正确的数字！")

   found = False
   for staff in self.staffs:
         if staff.get_uid() == uid:
            print(f"{staff.get_name()}，工号：{staff.get_uid()}，当前职位：{staff.get_level()}，当前薪资：{staff.get_salary()}")
            found = True
            break
   if not found:
         print("该工号不存在！")
         return

   while True:
         try:
            increase_level = int(input("请输入需要增加的级数："))
            if increase_level < 1:
               print("增加级数必须大于0！")
               continue
            break
         except ValueError:
            print("请输入正确的数字！")

   job_grade_max = {"E": 10, "T": 6, "M": 3}
   current_job = staff.get_job()
   current_grade = staff.get_grade()
   new_grade = current_grade + increase_level

   if new_grade <= job_grade_max:
         staff.grade = new_grade
         print(f"升级成功！")
         print(f"{staff.get_name()}，工号：{staff.get_uid()}，升级后职位：{staff.get_level()}，升级后薪资：{staff.get_salary()}")
   else:
         if current_job == "M":
            print("已经是最高职位，无法继续升职！")
            return
         if current_job == "E":
            new_staff = Teamleader(staff.uid)
         else:
            new_staff = Manager(staff.uid)
         new_staff.name = staff.get_name()
         new_staff.year = staff.get_year()
         new_staff.grade = 1
         old_salary = staff.get_salary()
         new_salary = new_staff.get_salary()
         change = new_salary - old_salary
         idx = self.staffs.index(staff)
         self.staffs = new_staff
         print("升级成功！")
         print(f"{new_staff.name}，工号：{new_staff.uid}，升级后职位：{new_staff.get_level()}，升级后薪资：{new_salary}({change:+.0f})")

def level_down(self):
   while True:
         try:
            uid = int(input("请输入工号："))
            break
         except ValueError:
            print("请输入正确的数字！")

   found = False
   for staff in self.staffs:
         if staff.get_uid() == uid:
            print(f"{staff.get_name()}，工号：{staff.get_uid()}，当前职位：{staff.get_level()}，当前薪资：{staff.get_salary()}")
            found = True
            break
   if not found:
         print("该工号不存在！")
         return

   while True:
         try:
            demote_level = int(input("请输入需要减少的级数："))
            if demote_level < 1:
               print("减少级数必须大于0！")
               continue
            break
         except ValueError:
            print("请输入正确的数字！")

   job_grade_max = {"E": 10, "T": 6, "M": 3}
   current_job = staff.get_job()
   current_grade = staff.get_grade()
   new_grade = current_grade - demote_level

   if new_grade >= 1:
         staff.grade = new_grade
         print("降级成功！")
         print(f"{staff.get_name()}，工号：{staff.get_uid()}，降级后职位：{staff.get_level()}，降级后薪资：{staff.get_salary()}")
   else:
         if current_job == "E":
            print("已经是最低职位，无法继续降职！")
            return
         if current_job == "T":
            new_staff = Employee(staff.uid)
         else:
            new_staff = Teamleader(staff.uid)
         new_staff.name = staff.get_name()
         new_staff.year = staff.get_year()
         new_staff.grade = job_grade_max
         old_salary = staff.get_salary()
         new_salary = new_staff.get_salary()
         change = new_salary - old_salary
         idx = self.staffs.index(staff)
         self.staffs = new_staff
         print("降级成功！")
         print(f"{new_staff.name}，工号：{new_staff.uid}，升级后职位：{new_staff.get_level()}，升级后薪资：{new_salary}({change:+.0f})")

def main():
manage = Management()
while True:
   print("1.录入;2.查询;3.升级;4.降级;5.退出：")
   choice = input("请输入您的选择：")
   if choice == "1":
         manage.add_staff()
   elif choice == "2":
         manage.search()
   elif choice == "3":
         manage.level_up()
   elif choice == "4":
         manage.level_down()
   elif choice == "5":
         print("谢谢使用！")
         break
   else:
         print("选择输入错误！")

Raizertapissic 发表于 2026-4-6 14:03:34

请回复您的答案^_^

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

第 0 题的答案是：多态 = 同一个方法，不同对象不同表现

第 1 题的答案是：代码更简洁，更容易扩展

第 2 题的答案是：是

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

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

第 5 题的答案是：不是

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

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

铭记太阳 发表于 2026-4-5 00:44:38

0
同一个运算符、函数，面对不同对象有不同的作用效果
1
1.提高代码的灵活性和可扩展性
2.实现“鸭子类型”
3.代码简洁，不用写大量的判断语句来判断对象的类型
4.接口统一，降低学习成本

2
算多态

3
如果它走起来像鸭子，叫起来也像鸭子，那它就是鸭子

4
降低了耦合

5
不是

动动脚，现在已经不能这么叫了，每次题都得拼尽全力
0
不过上上节跟着敲了一个grok，上节自己又自创了一个超市，现在会写这种模块化编程了，在检测地方额外加入mixin函数
不是，这工资有问题啊老板，E10是3000+500*10,升级后T1 4000 + 800*1
什么明争暗斗，明升实降
这一次是真的独立完成的，呱唧呱唧呱唧

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 = salary

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):
   n = self.get_job()
   if n == 'E':
         return 3000 + 500*self.get_grade() + 50*self.get_year()
   elif n == 'T':
         return 4000 + 800*self.get_grade() + 100*self.get_year()
   elif n == 'M':
         return 5000 + 1000*(self.get_grade()+self.get_year())

class CheckMixin:
def Job_check(self,job):
   while (job != 'E') and (job != 'T') and (job != 'M'):
         job = input('输入错误，请重新输入职位：E T M')
   return job
def Grade_check(self,grade,job):
   while job == 'E' and (grade<1 or grade >10):
         grade= int(input('该级别最高为10，请重新输入级别'))
   while job == 'T' and (grade<1 or grade >6):
         grade= int(input('该级别最高为6，请重新输入级别'))
   while job == 'M' and (grade<1 or grade >3):
         grade= int(input('该级别最高为3，请重新输入级别'))
   return grade

class Management(CheckMixin):

database=[]
ChuShi_uid = 10000
def welcome(self):
   order = int(input('1录入 2查询 3升级 4降级 5退出'))
   while order != 5:
         if order == 1:
            self.database.append(self.Luru())
         elif order == 2:
            self.Chaxun()
         elif order == 3:
            self.Shengji()
         elif order == 4:
            self.Jiangji()

         order = int(input('1录入 2查询 3升级 4降级 5退出'))

def Luru(self):
   uid = self.ChuShi_uid
   self.ChuShi_uid += 1
   name = input('姓名')
   job = input('职位：E T M')
   job = self.Job_check(job)

   grade= int(input('级别'))
   grade = self.Grade_check(grade,job)

   year = int(input('工龄'))
   return Yuangong(uid,name,job,grade,year)

def Chaxun(self):
   order = int(input('1员工查询 2职位查询'))
   if order == 1:
         uid = int(input('请输入工号'))
         for i in self.database:
            if i.get_uid() == uid:
               print(f'姓名{i.get_name()}\n职位{i.get_job()}')
               print(f'级别{i.get_grade()}\n工龄{i.get_year()}\n薪资{i.salary()}')
               break
         else:
            print('该工号不存在')
   elif order == 2:
         job = input('请输入要查询的职位E T M')
         job = self.Job_check(job)
         renshu = 0
         for i in self.database:
            if i.get_job() == job:
               print(f'{i.get_uid()} - {i.get_name()}')
               renshu += 1
         print(f'目前{job}共有{renshu}人')

def Shengji(self):
   uid = int(input('请输入工号'))
   for i in self.database:
         if i.get_uid() == uid:
               break
   else:
            print('该工号不存在')
   salary = i.salary()
   print(f'{i.get_name()} 工号{i.get_uid()},职位{i.get_job()}{i.get_grade()},薪资{salary}')
   lvlup = int(input('请输入增加的级数'))
   i.grade += lvlup
   if i.job == 'E' and i.grade > 10:
         i.job = 'T'
         i.grade = 1
   elif i.job == 'T' and i.grade > 6:
         i.job = 'M'
         i.grade = 1
   elif i.job == 'M' and i.grade >3:
         print('升级不能超过极限，最高等级为M3')
         i.grade = 3
   new_salary = i.salary()
   print(f'{i.get_name()} 工号{i.get_uid()},'
         f'升级后职位{i.get_job()}{i.get_grade()},薪资{new_salary}({(new_salary-salary):+})')

def Jiangji(self):
   uid = int(input('请输入工号'))
   for i in self.database:
         if i.get_uid() == uid:
               break
   else:
            print('该工号不存在')
   salary = i.salary()
   print(f'{i.get_name()} 工号{i.get_uid()},职位{i.get_job()}{i.get_grade()},薪资{salary}')
   lvldown = int(input('请输入降低的级数'))
   i.grade -= lvldown
   if i.job == 'E' and i.grade < 1:
         print('不能再降低了，老板')
         i.grade = 1
   elif i.job == 'T' and i.grade < 1:
         i.job = 'E'
         i.grade = 10
   elif i.job == 'M' and i.grade <1:
         i.job = 'T'
         i.grade = 6
   new_salary = i.salary()
   print(f'{i.get_name()} 工号{i.get_uid()},'
         f'降级后职位{i.get_job()}{i.get_grade()},薪资{new_salary}({(new_salary-salary):+})')

m = Management()
m.welcome()

困在雨天里 发表于 2026-3-28 16:29:34

请回复您的答案^_^

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

第 0 题的答案是：通过方法重写和鸭子类型

第 1 题的答案是：提高灵活性

第 2 题的答案是：可以，运算符多态

第 3 题的答案是：如果他走起来像鸭子。。。。。

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

第 5 题的答案是：不

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

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

261329663 发表于 2026-3-27 23:41:57

请回复您的答案^_^答案

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

深津冥夜 发表于 2026-3-24 16:03:57

zhaobowen2045 发表于 2026-3-19 14:56:28

请回复您的答案^_^

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

第 0 题的答案是：构造出的对象只要有类中对应的函数，函数都能正常工作

第 1 题的答案是：多态不会影响类中的配置，可以创建多个类，且能单独修改配置

第 2 题的答案是：算，+多态

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

第 4 题的答案是：提高了内聚

第 5 题的答案是：不算

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

请将第 0 题的代码写在下方：
class EmployeeBase:
"""员工基类，定义公共属性和方法"""
next_uid = 10000# 类变量记录下一个可用工号

def __init__(self, name, grade, year):
   self.name = name
   self.grade = grade
   self.year = year
   self.uid = EmployeeBase.next_uid
   EmployeeBase.next_uid += 1
   self.job = ""# 由子类设置

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):
   raise NotImplementedError("子类必须实现 salary 方法")

def promote(self, levels):
   new_grade = self.grade + levels
   max_grade = self.__class__.max_grade

   if new_grade <= max_grade:
         self.grade = new_grade
         print(f"升级成功！新级别：{self.grade}")
         return

   # 需要升职
   if isinstance(self, Employee):
         self.__class__ = TeamLeader
         self.job = "组长"
         self.grade = 1
         print("升级：普通员工 → 组长，级别重置为1")
   elif isinstance(self, TeamLeader):
         self.__class__ = Manager
         self.job = "经理"
         self.grade = 1
         print("升级：组长 → 经理，级别重置为1")
   elif isinstance(self, Manager):
         self.grade = max_grade
         print("经理已达最高职位，无法升职，级别设为最高级3")

def demote(self, levels):
   new_grade = self.grade - levels
   if new_grade >= 1:
         self.grade = new_grade
         print(f"降级成功！新级别：{self.grade}")
         return

   # 需要降职
   if isinstance(self, Manager):
         self.__class__ = TeamLeader
         self.job = "组长"
         self.grade = TeamLeader.max_grade
         print("降级：经理 → 组长，级别设为组长最高级6")
   elif isinstance(self, TeamLeader):
         self.__class__ = Employee
         self.job = "普通员工"
         self.grade = Employee.max_grade
         print("降级：组长 → 普通员工，级别设为普通员工最高级10")
   elif isinstance(self, Employee):
         self.grade = 1
         print("普通员工已达最低职位，无法再降，级别设为1")

def __str__(self):
   return f"工号：{self.uid} | 姓名：{self.name} | 职位：{self.job} | 级别：{self.grade} | 工龄：{self.year} | 工资：{self.salary():.2f}"

class Employee(EmployeeBase):
max_grade = 10

def __init__(self, name, grade, year):
   super().__init__(name, grade, year)
   self.job = "普通员工"

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

class TeamLeader(EmployeeBase):
max_grade = 6

def __init__(self, name, grade, year):
   super().__init__(name, grade, year)
   self.job = "组长"

def salary(self):
   return 4000 + 800 * self.grade + 100 * self.year

class Manager(EmployeeBase):
max_grade = 3

def __init__(self, name, grade, year):
   super().__init__(name, grade, year)
   self.job = "经理"

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

employees = []# 全局员工列表

def find_employee_by_uid_or_name(key):
"""根据工号（字符串或数字）或姓名查找员工"""
key = key.strip()# 去除首尾空格
for emp in employees:
   if str(emp.uid) == key or emp.name == key:
         return emp
return None

def add_employee():
print("\n--- 录入员工 ---")
name = input("姓名：")
print("职位：1.普通员工2.组长3.经理")
job_choice = input("请选择职位编号：")
while job_choice not in ('1', '2', '3'):
   job_choice = input("输入错误，请重新选择：")

try:
   grade = int(input("级别："))
   year = int(input("工龄："))
except ValueError:
   print("级别和工龄必须为整数，录入失败")
   return

if job_choice == '1':
   if grade < 1 or grade > Employee.max_grade:
         print(f"普通员工级别应在1~{Employee.max_grade}之间，录入失败")
         return
   emp = Employee(name, grade, year)
elif job_choice == '2':
   if grade < 1 or grade > TeamLeader.max_grade:
         print(f"组长级别应在1~{TeamLeader.max_grade}之间，录入失败")
         return
   emp = TeamLeader(name, grade, year)
else:
   if grade < 1 or grade > Manager.max_grade:
         print(f"经理级别应在1~{Manager.max_grade}之间，录入失败")
         return
   emp = Manager(name, grade, year)

employees.append(emp)
print("录入成功！")
print(emp)

def query_employee():
print("\n--- 员工查询 ---")
key = input("请输入工号或姓名：")
emp = find_employee_by_uid_or_name(key)
if emp:
   print(emp)
else:
   print("未找到该员工")

def query_job():
print("\n--- 职位查询 ---")
print("职位：1.普通员工2.组长3.经理")
job_choice = input("请选择职位编号：")
job_map = {'1': '普通员工', '2': '组长', '3': '经理'}
job_name = job_map.get(job_choice)
if not job_name:
   print("无效选择")
   return

found =
if not found:
   print(f"没有找到{job_name}")
else:
   print(f"--- {job_name}列表 ---")
   for emp in found:
         print(emp)

def promote_employee():
print("\n--- 员工升级 ---")
key = input("请输入要升级的员工工号或姓名：")
emp = find_employee_by_uid_or_name(key)
if not emp:
   print("员工不存在")
   return
try:
   levels = int(input("请输入增加的级别数："))
   if levels <= 0:
         print("级别数必须为正整数")
         return
except ValueError:
   print("请输入整数")
   return
emp.promote(levels)
print("升级后信息：", emp)

def demote_employee():
print("\n--- 员工降级 ---")
key = input("请输入要降级的员工工号或姓名：")
emp = find_employee_by_uid_or_name(key)
if not emp:
   print("员工不存在")
   return
try:
   levels = int(input("请输入减少的级别数："))
   if levels <= 0:
         print("级别数必须为正整数")
         return
except ValueError:
   print("请输入整数")
   return
emp.demote(levels)
print("降级后信息：", emp)

def main():
while True:
   print("\n" + "=" * 30)
   print("企业员工管理系统")
   print("1. 录入员工")
   print("2. 员工查询（按工号/姓名）")
   print("3. 职位查询")
   print("4. 员工升级")
   print("5. 员工降级")
   print("0. 退出")
   choice = input("请选择操作：")

   if choice == '1':
         add_employee()
   elif choice == '2':
         query_employee()
   elif choice == '3':
         query_job()
   elif choice == '4':
         promote_employee()
   elif choice == '5':
         demote_employee()
   elif choice == '0':
         print("感谢使用，再见！")
         break
   else:
         print("无效输入，请重新选择")

if __name__ == "__main__":
main()

OnlyDragonKing 发表于 2026-3-18 19:20:40

请回复您的答案^_^

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

第 0 题的答案是：1

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

胡佳彬 发表于 2026-3-16 22:48:33

zttz 发表于 2026-3-10 22:48:33

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：
keyi
第 3 题的答案是：

第 4 题的答案是：
降低耦合
第 5 题的答案是：
bushi
-------- 动动手 --------

请将第 0 题的代码写在下方：
class employee:
name=''
job=''
grade=1
year=0
uid=10000
class manage():
employees={}
def salary(self,uid):
   temp=self.employees
   if temp.job=='E':
         return (3000+500*temp.grade+50*temp.year)
   elif temp.job=='T':
         return (4000+800*temp.grade+100*temp.year)
   else:
         return (5000+1000*(temp.grade+temp.year))
def adopt(self):
   temp=employee()
   temp.uid+=len(self.employees)
   self.employees=temp
   temp.name=input("姓名：")
   temp.job=input("职位（E.普通员工；T.组长；M.经理）：")
   temp.year=int(input("工龄："))
   temp.grade=int(input("级别："))
   while 1:
         if temp.job=='E':
            if temp.grade<=10:
               break
            else:
               temp.grade=int(input("该职位最高级别为10，请重新录入级别："))
         elif temp.job=='T':
            if temp.grade<=6:
               break
            else:
               temp.grade=int(input("该职位最高级别为6，请重新录入级别："))
         else:
            if temp.grade<=3:
               break
            else:
               temp.grade=int(input("该职位最高级别为3，请重新录入级别："))
   print("录入成功！姓名：{}，工号：{}，薪资：{}".format(temp.name,temp.uid,self.salary(temp.uid)))
def detect(self):
   p=int(input("1.员工查询;2.职位查询："))
   if p==1:
         uid=int(input("请输入工号："))
         if uid in self.employees.keys():
            temp=self.employees
            print("姓名：{}".format(temp.name))
            print("职位：{}".format(temp.job))
            print("级别：{}".format(temp.grade))
            print("工龄：{}".format(temp.year))
            print("薪资：{}".format(self.salary(uid)))
         else:
            print("该工号不存在！")
   else:
         j=input("职位（E.普通员工；T.组长；M.经理）：")
         if j=='E':
            count=0
            temp1=[]
            for i in self.employees:
               if self.employees.job=='E':
                     count+=1
                     temp1.append(i)
            print("目前普通员工共有 {} 人:".format(count))
            for i in temp1:
               print("{} - {}".format(self.employees.uid,self.employees.name))
            del temp1
         if j=='T':
            count=0
            temp1=[]
            for i in self.employees:
               if self.employees.job=='T':
                     count+=1
                     temp1.append(i)
            print("目前普通员工共有 {} 人:".format(count))
            for i in temp1:
               print("{} - {}".format(self.employees.uid,self.employees.name))
            del temp1
         if j=='M':
            count=0
            temp1=[]
            for i in self.employees:
               if self.employees.job=='M':
                     count+=1
                     temp1.append(i)
            print("目前普通员工共有 {} 人:".format(count))
            for i in temp1:
               print("{} - {}".format(self.employees.uid,self.employees.name))
            del temp1
def upgrade(self):
   uid=int(input("请输入工号："))
   if uid in self.employees.keys():
         temp=self.employees
         print("{}, 工号：{}, 当前职位：{}{}, 当前薪资：{}".format(temp.name,temp.uid,temp.job,temp.grade,self.salary(uid)))
         up=int(input("请输入需要增加的级数："))
         temp.grade+=up
         _=0
         if temp.job=='E':
            _+=0
         elif temp.job=='T':
            _+=10
         else:
            _+=16
         if temp.grade+_<=10:
            temp.job='E'
         elif temp.grade+_>10 and temp.grade+_<=16:
            temp.job='T'
            temp.grade=temp.grade+_-10
         else:
            temp.job='M'
            if temp.grade-16>3:
               temp.grade=3
            else:
               temp.grade=temp.grade+_-16
         print("升级成功！")
         print("{}, 工号：{}, 升级后职位：{}{}, 当前薪资：{}".format(temp.name,temp.uid,temp.job,temp.grade,self.salary(uid)))
def down(self):
   uid=int(input("请输入工号："))
   if uid in self.employees.keys():
         temp=self.employees
         print("{}, 工号：{}, 当前职位：{}{}, 当前薪资：{}".format(temp.name,temp.uid,temp.job,temp.grade,self.salary(uid)))
         down=int(input("请输入需要减少的级数："))
         temp.grade-=down
         _=0
         if temp.job=='E':
            _+=0
         elif temp.job=='T':
            _+=10
         else:
            _+=16
         if temp.grade+_<=10:
            temp.job='E'
            if temp.grade+_<=0:
               temp.grade=1
            else:
               temp.grade+=_
         elif temp.grade+_>10 and temp.grade+_<=16:
            temp.job='T'
            temp.grade=temp.grade+_-10
         else:
            temp.job='M'
            temp.grade=temp.grade+_-16
         print("降级成功！")
         print("{}, 工号：{}, 升级后职位：{}{}, 当前薪资：{}".format(temp.name,temp.uid,temp.job,temp.grade,self.salary(uid)))
def welcome(self):
   while 1:
         num=int(input("1.录入;2.查询;3.升级;4.降级;5.退出："))
         if num==1:
            self.adopt()
         elif num==2:
            self.detect()
         elif num==3:
            self.upgrade()
         elif num==4:
            self.down()
         else:
            break
         print()
a=manage()
a.welcome()

Collider-M31 发表于 2026-3-10 18:39:46

maweijia 发表于 2026-3-10 16:57:37

123jiayou 发表于 2026-3-8 15:51:05

hunk776 发表于 2026-3-6 14:43:16

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

请将第 0 题的代码写在下方：
class YG:
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_year(self):
   return self.year
def get_grade(self):
   return self.grade

class Employee(YG):
def salary(self):
   return self.grade*500+50*self.year+3000
class Teamleader(YG):
def salary(self):
   return self.grade*800+100*self.year+4000
class Manager(YG):
def salary(self):
   return (self.grade+self.year)*1000+5000

class Manage( ):
def __init__(self):
   self.members = {}
   self.cardid = 10000

# 程序功能入口
def welcome(self):
   ins = 0
   while ins != '5':
         ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出程序：")
         if ins == '1':
            self.luru()
         if ins == '2':
            self.chaxun()
         if ins == '3':
            self.shengji()
         if ins == '4':
            self.jiangji()
         if ins == '5':
            print("感谢使用")

def luru(self):
   name = input("姓名：")
   job = input("职位(E.普通员工T.组长M.经理)：")
   year = int(input("工龄："))

   if job=='E':
         grade = int(input("级别："))
         while grade>10:
            grade = int(input('该职位最高为10级，请重新输入'))
         ee = Employee(name, job, grade, year,self.cardid)
         self.members = ee
   if job=='T':
         grade = int(input("级别："))
         while grade>6:
            grade = int(input('该职位最高为6级，请重新输入'))
         tt = Teamleader(name, job, grade, year,self.cardid)
         self.members = tt
   if job=='M':
         grade = int(input("级别："))
         while grade>3:
            grade = int(input('该职位最高为3级，请重新输入'))
         mm = Manager(name, job, grade, year,self.cardid)
         self.members = mm
   print(f"录入成功！姓名{name},工号{self.cardid},薪资：{self.members.salary()}")
   self.cardid += 1

def chaxun(self):
   c=input('1.员工查询 2.职位查询：')
   if c=='1':
         card=int(input('请输入工号：'))
         if not self.members.get(card):
            print('员工号不存在')
            return 0
         else:
            print(f'姓名：{self.members.get(card).get_name()}')
            print(f'职位：{self.members.get(card).get_job()}')
            print(f'级别：{self.members.get(card).get_grade()}')
            print(f'工龄：{self.members.get(card).get_year()}')
            print(f'薪资：{self.members.get(card).salary()}')
   if c=='2':
         job=input('请输入要查询的职位(E.普通员工T.组长M.经理):')
         if job=='E':
            jobname='普通员工'
         if job=='T':
            jobname='组长'
         if job=='M':
            jobname='经理'
         js=0
         cxxs=[]
         for i in self.members:
            if self.members.job==job:
               js=js+1
               cxxs.append(f'{self.members.uid} - {self.members.name}')
         if js==0:
            print(f'目前公司没有{jobname}')
         else:
            print(f'目前{jobname}共有{js}人')
            for i in cxxs:
               print(i)

def shengji(self):
   card=int(input('请输入工号：'))
   if not self.members.get(card):
         print('员工号不存在！')
         return 0
   else:
         print(f'{self.members.get(card).get_name()},工号：{card},当前职位：{self.members.get(card).get_job()}{self.members.get(card).get_grade()}，当前薪资：{self.members.get(card).salary()}')
         sj=int(input('请输入需要增加的级数：'))
         newgrade=self.members.get(card).get_grade()+sj
         if self.members.get(card).get_job()=='E':
            if newgrade > 10:
               tt=Teamleader(self.members.get(card).name,'T',1,self.members.get(card).year,card)
               print('升级成功')
               print(f'{tt.get_name()},工号：{card},当前职位：{tt.get_job()}{tt.get_grade()}，升级后薪资：{tt.salary()}(+{tt.salary()-self.members.get(card).salary()})')
               self.members=tt
            else:
               ee=Employee(self.members.get(card).name,'E',newgrade,self.members.get(card).year,card)
               print('升级成功')
               print(f'{ee.get_name()},工号：{card},当前职位：{ee.get_job()}{ee.get_grade()}，升级后薪资：{ee.salary()}(+{ee.salary()-self.members.get(card).salary()})')
               self.members=ee
            return 0
         if self.members.get(card).get_job()=='T':
            if newgrade > 6:
               mm=Manager(self.members.get(card).name,'M',1,self.members.get(card).year,card)
               print('升级成功')
               print(f'{mm.get_name()},工号：{card},当前职位：{mm.get_job()}{mm.get_grade()}，升级后薪资：{mm.salary()}(+{mm.salary()-self.members.get(card).salary()})')
               self.members=mm
            else:
               tt=Teamleader(self.members.get(card).name,'T',1,self.members.get(card).year,card)
               print('升级成功')
               print(f'{tt.get_name()},工号：{card},当前职位：{tt.get_job()}{tt.get_grade()}，升级后薪资：{tt.salary()}(+{tt.salary()-self.members.get(card).salary()})')
               self.members=tt
            return 0
         if self.members.get(card).get_job()=='M':
            if self.members.get(card).grade==3:
               print('您已经是最高等级')
               return 0
            if newgrade > 3:
               mm=Manager(self.members.get(card).name,'M',3,self.members.get(card).year,card)
               print('升级成功')
               print(f'{mm.get_name()},工号：{card},当前职位：{mm.get_job()}{mm.get_grade()}，升级后薪资：{mm.salary()}(+{mm.salary()-self.members.get(card).salary()})')
               self.members=mm
            else:
               mm=Manager(self.members.get(card).name,'M',newgrade,self.members.get(card).year,card)
               print('升级成功')
               print(f'{mm.get_name()},工号：{card},当前职位：{mm.get_job()}{mm.get_grade()}，升级后薪资：{mm.salary()}(+{mm.salary()-self.members.get(card).salary()})')
               self.members=mm
            return 0
def jiangji(self):
   card=int(input('请输入工号：'))
   if not self.members.get(card):
         print('员工号不存在')
         return 0
   else:
         print(f'{self.members.get(card).get_name()},工号：{card},当前职位：{self.members.get(card).get_job()}{self.members.get(card).get_grade()}，当前薪资：{self.members.get(card).salary()}')
         sj=int(input('请输入需要减少的级数：'))
         newgrade=self.members.get(card).get_grade()-sj
         if self.members.get(card).get_job()=='M':
            if newgrade < 0:
               tt=Teamleader(self.members.get(card).name,'T',6,self.members.get(card).year,card)
               print('降级成功')
               print(f'{tt.get_name()},工号：{card},当前职位：{tt.get_job()}{tt.get_grade()}，降级后薪资：{tt.salary()}(-{self.members.get(card).salary()-tt.salary()})')
               self.members=tt
            else:
               mm=Manager(self.members.get(card).name,'M',newgrade,self.members.get(card).year,card)
               print('降级成功')
               print(f'{mm.get_name()},工号：{card},当前职位：{mm.get_job()}{mm.get_grade()}，降级后薪资：{mm.salary()}(-{self.members.get(card).salary()-mm.salary()})')
               self.members=mm
            return 0
         if self.members.get(card).get_job()=='T':
            if newgrade < 0:
               ee=Employee(self.members.get(card).name,'E',10,self.members.get(card).year,card)
               print('降级成功')
               print(f'{ee.get_name()},工号：{card},当前职位：{ee.get_job()}{ee.get_grade()}，降级后薪资：{ee.salary()}(-{self.members.get(card).salary()-ee.salary()})')
               self.members=ee
            else:
               tt=Teamleader(self.members.get(card).name,'T',1,self.members.get(card).year,card)
               print('降级成功')
               print(f'{tt.get_name()},工号：{card},当前职位：{tt.get_job()}{tt.get_grade()}，降级后薪资：{tt.salary()}(-{self.members.get(card).salary()-tt.salary()})')
               self.members=tt
            return 0
         if self.members.get(card).get_job()=='E':
            if self.members.get(card).grade==1:
               print('您已经是最低等级')
               return 0
            if newgrade < 1:
               ee=Employee(self.members.get(card).name,'E',1,self.members.get(card).year,card)
               print('降级成功')
               print(f'{ee.get_name()},工号：{card},当前职位：{ee.get_job()}{ee.get_grade()}，降级后薪资：{ee.salary()}(-{self.members.get(card).salary()-mm.salary()})')
               self.members=ee
            else:
               ee=Employee(self.members.get(card).name,'E',newgrade,self.members.get(card).year,card)
               print('降级成功')
               print(f'{ee.get_name()},工号：{card},当前职位：{ee.get_job()}{ee.get_grade()}，降级后薪资：{ee.salary()}(-{self.members.get(card).salary()-ee.salary()})')
               self.members=ee
            return 0

def main():
m = Manage()
m.welcome()

H.T.Black 发表于 2026-3-6 11:00:46

请回复您的答案^_^

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

第 0 题的答案是：相同的函数不同的功能

第 1 题的答案是：多态的优势是在继承中相同的方法可以自定义

第 2 题的答案是：可以

第 3 题的答案是：不知

第 4 题的答案是：高内聚

第 5 题的答案是：不能

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

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

李小样 发表于 2026-3-5 20:10:55

过客久居 发表于 2026-3-3 20:19:07

black7788 发表于 2026-3-1 20:45:57

kissmarlboro 发表于 2026-2-27 17:24:08

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：可以

第 3 题的答案是：

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

第 5 题的答案是：不算

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

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

页: 1 2 3 [4] 5 6 7 8 9 10 11 12 13

鱼C论坛's Archiver