第063讲：类和对象（VI）| 课后测试题及答案

huayangshihan

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

zzj375100270

请回复您的答案^_^

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

第 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[job]:
                    print(f"级别输入错误！{job_grade_max[job]}级为最高级别")
                    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[job]}！")
            return
        else:
            print(f"目前{level_lst[job]}共有{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[current_job]:
            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[idx] = 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[new_staff.job]
            old_salary = staff.get_salary()
            new_salary = new_staff.get_salary()
            change = new_salary - old_salary
            idx = self.staffs.index(staff)
            self.staffs[idx] = 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

请回复您的答案^_^

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

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

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

第 2 题的答案是：是

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

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

第 5 题的答案是：不是

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

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

铭记太阳

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()

困在雨天里

请回复您的答案^_^

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

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

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

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

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

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

第 5 题的答案是：不

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

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

261329663

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

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

深津冥夜

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

zhaobowen2045

请回复您的答案^_^

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

第 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 = [emp for emp in employees if emp.job == job_name]
    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

请回复您的答案^_^

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

第 0 题的答案是：1

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

胡佳彬

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

zttz

请回复您的答案^_^

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

第 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[uid]
        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.uid]=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[uid]
                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[i].job=='E':
                        count+=1
                        temp1.append(i)
                print("目前普通员工共有 {} 人:".format(count))
                for i in temp1:
                    print("{} - {}".format(self.employees[i].uid,self.employees[i].name))
                del temp1
            if j=='T':
                count=0
                temp1=[]
                for i in self.employees:
                    if self.employees[i].job=='T':
                        count+=1
                        temp1.append(i)
                print("目前普通员工共有 {} 人:".format(count))
                for i in temp1:
                    print("{} - {}".format(self.employees[i].uid,self.employees[i].name))
                del temp1
            if j=='M':
                count=0
                temp1=[]
                for i in self.employees:
                    if self.employees[i].job=='M':
                        count+=1
                        temp1.append(i)
                print("目前普通员工共有 {} 人:".format(count))
                for i in temp1:
                    print("{} - {}".format(self.employees[i].uid,self.employees[i].name))
                del temp1
    def upgrade(self):
        uid=int(input("请输入工号："))
        if uid in self.employees.keys():
            temp=self.employees[uid]
            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[uid]
            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

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

maweijia

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

123jiayou

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

hunk776

请回复您的答案^_^

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

第 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[self.cardid] = ee
        if job=='T':
            grade = int(input("级别："))
            while grade>6:
                grade = int(input('该职位最高为6级，请重新输入'))
            tt = Teamleader(name, job, grade, year,self.cardid)
            self.members[self.cardid] = tt
        if job=='M':
            grade = int(input("级别："))
            while grade>3:
                grade = int(input('该职位最高为3级，请重新输入'))
            mm = Manager(name, job, grade, year,self.cardid)
            self.members[self.cardid] = mm
        print(f"录入成功！姓名{name},工号{self.cardid},薪资：{self.members[self.cardid].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[i].job==job:
                    js=js+1
                    cxxs.append(f'{self.members[i].uid} - {self.members[i].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[card]=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[card]=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[card]=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[card]=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[card]=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[card]=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[card]=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[card]=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[card]=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[card]=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[card]=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[card]=ee
                return 0

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

H.T.Black

请回复您的答案^_^

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

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

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

第 2 题的答案是：可以

第 3 题的答案是：不知

第 4 题的答案是：高内聚

第 5 题的答案是：不能

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

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

李小样

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

过客久居

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

black7788

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

kissmarlboro

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：可以

第 3 题的答案是：

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

第 5 题的答案是：不算

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

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