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

tomo777

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

曾德华

#定义员工类，父类
class Staff:
    def __init__(self,name,job,grade,year):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
    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(Staff):
    def __init__(self,name,job,grade,year,):
        super().__init__(name,job,grade,year)
    def salary(self):
        return 3000 + 500 * self.grade + 50 * self.year
#继承父类，普通员工类        
class Teamleader(Staff):
    def __init__(self,name,job,grade,year,):
        super().__init__(name,job,grade,year)
    def salary(self):
        return 4000 + 800 * self.grade + 100 * self.year
#继承父类，经理类
class Manager(Staff):
    def __init__(self,name,job,grade,year,):
        super().__init__(name,job,grade,year)
    def salary(self):
        return 5000 + 1000 * (self.grade + self.year)
class Manage():
    user_id = 10000
    staff_dict = {}
    def entering(self):
        name = input("姓名：")
        job = input("职位(E.普通员工;T:组长;M:经理;)")
        year = int(input("工龄："))
        grade = int(input("级别："))
        if job == "E":
            mannger = Employee(name,job,grade,year)
            self.staff_dict[self.user_id] = mannger
            print(f"录入成功：姓名：{name},工号：{self.user_id},薪资：{mannger.salary()}.")
            self.user_id += 1
        elif job == "T":
            mannger = Teamleader(name,job,grade,year)
            self.staff_dict[self.user_id] = mannger
            print(f"录入成功：姓名：{name},工号：{self.user_id},薪资：{mannger.salary()}.")
            self.user_id += 1
        elif job == "M":
            mannger = Manager(name,job,grade,year)
            self.staff_dict[self.user_id] = mannger
            print(f"录入成功：姓名：{name},工号：{self.user_id},薪资：{mannger.salary()}.")
            self.user_id += 1
    def user_id_ck(self):#输入user_id，并检查是有输入错误
        user_id = int(input("请输入工号："))
        while user_id not in self.staff_dict:
            user_id = int(input("工号不存在，请重新输入："))
        return user_id
    def query(self):#查询工号/查询职位人数
        query_num = int(input("1、员工查询；2、职位查询："))
        if query_num == 1:
            user_id = self.user_id_ck()
            print(f"姓名：{self.staff_dict[user_id].name}")
            print(f"职位：{self.staff_dict[user_id].job}")
            print(f"级别：{self.staff_dict[user_id].grade}")
            print(f"工龄：{self.staff_dict[user_id].year}")
            print(f"薪资：{self.staff_dict[user_id].salary()}")
        elif query_num == 2:
            job = input("职位(E.普通员工;T:组长;M:经理;)")
            job_num = 0
            job_name = "普通员工" if job == "E" else "组长" if job == "T" else "经理"
            for i in self.staff_dict.values():
                if i.job == job:
                    job_num += 1
            print(f"目前{job_name}共有{job_num}名")
            for x in self.staff_dict:
                if self.staff_dict.get(x).job == job:
                    print(f"{x} - {self.staff_dict.get(x).name}")
    def up_grade(self):
        user_id = self.user_id_ck()
        crt_salary = self.staff_dict[user_id].salary()
        print(f"{self.staff_dict[user_id].name},工号：{user_id},当前职位：{self.staff_dict[user_id].job+str(self.staff_dict[user_id].grade)},当前薪资:{crt_salary}")
        up_grade_num = int(input("请输入需要增加的级数："))
        self.staff_dict[user_id].grade += up_grade_num
        if (self.staff_dict[user_id].job == "E") and (self.staff_dict[user_id].grade > 10):
            self.staff_dict[user_id] = Teamleader(self.staff_dict[user_id].name,"T",1,self.staff_dict[user_id].year)
        elif (self.staff_dict[user_id].job == "T") and (self.staff_dict[user_id].grade > 6):
            self.staff_dict[user_id] = Manager(self.staff_dict[user_id].name,"M",1,self.staff_dict[user_id].year)
        elif (self.staff_dict[user_id].job == "M") and (self.staff_dict[user_id].grade > 3):
            self.staff_dict[user_id].grade = 3
        print(f"{self.staff_dict[user_id].name},工号：{user_id},当前职位：{self.staff_dict[user_id].job+str(self.staff_dict[user_id].grade)},调整之后薪资:{self.staff_dict[user_id].salary()}({self.staff_dict[user_id].salary()-crt_salary:+})")
    def down_grade(self):
        user_id = self.user_id_ck()
        crt_salary = self.staff_dict[user_id].salary()
        print(f"{self.staff_dict[user_id].name},工号：{user_id},当前职位：{self.staff_dict[user_id].job+str(self.staff_dict[user_id].grade)},当前薪资:{crt_salary}")
        down_grade_num = int(input("请输入需要下降的级数："))
        self.staff_dict[user_id].grade -= down_grade_num
        if (self.staff_dict[user_id].job == "E") and (self.staff_dict[user_id].grade < 0):
            self.staff_dict[user_id].grade = 1
        elif (self.staff_dict[user_id].job == "T") and (self.staff_dict[user_id].grade < 0):
            self.staff_dict[user_id] = Employee(self.staff_dict[user_id].name,"E",10,self.staff_dict[user_id].year)
        elif (self.staff_dict[user_id].job == "M") and (self.staff_dict[user_id].grade < 0):
            self.staff_dict[user_id] = Teamleader(self.staff_dict[user_id].name,"T",6,self.staff_dict[user_id].year)
        print(f"{self.staff_dict[user_id].name},工号：{user_id},当前职位：{self.staff_dict[user_id].job+str(self.staff_dict[user_id].grade)},调整之后薪资:{self.staff_dict[user_id].salary()}({self.staff_dict[user_id].salary()-crt_salary:+})")
    def main(self):
        while True:
            i = int(input("1、录入；2、查询；3、升级；4、降级；5、退出；"))
            if i == 5:
                break
            elif i == 1:
                self.entering()
            elif i == 2:
                self.query()
            elif i == 3:
                self.up_grade()
            elif i == 4:
                self.down_grade()
m=Manage()
m.main()

wdfwedw

请回复您的答案^_^

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

第 0 题的答案是：是要有相同方法不管是什么类型都可以调用

第 1 题的答案是：一个接口可以使用多个有相同类型的方法

第 2 题的答案是：可以

第 3 题的答案是：它长得像鸭子，游泳像鸭子，叫声像鸭子，那它很可能就是鸭子

第 4 题的答案是：低耦合

第 5 题的答案是：不属于

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

请将第 0 题的代码写在下方：
#公司员工管理

#储存员工信息
class Umessage:
    def __init__(self,uid,name,job,grade,year,salary):
        self.uid=uid
        self.name=name
        self.job=job
        self.grade=grade
        self.year=year
        self.salary=salary

#判断员工输入级别是否正常
class Is_gradeMixin:
    def is_grade(self,job):
        grade=int(input("级别:"))
        if job=='E':
            while grade>10:
                grade=int(input("该职位最高级别为10,请重新输入级别:"))
        elif job=='T':
            while grade>6:
                grade=int(input("该职位最高级别为6,请重新输入级别:"))
        else:
            
            while grade>3:
                grade=int(input("该职位最高级别为3,请重新输入级别:"))
        return grade
        
#计算员工薪资
class Calculate_salaryMixin:
    def calculate_salary(self,job,year,grade):
        if job=='E':
            salary=3000+500*grade+50*year
        if job=='T':
            salary=4000+800*grade+100*year
        if job=='M':
            salary=5000+1000*(year+grade)
        return salary

class Mange(Is_gradeMixin,Calculate_salaryMixin):
    def __init__(self):
        self.members={}
        self.uid=10000
        self.numberE=0
        self.numberT=0
        self.numberM=0

    #程序功能入口
    def welcome(self):
        ins=0
        print("欢迎使用鱼C办公室")
        while ins!='5':
            ins=input("1.录入;2.查询;3.升级;4.降级;5.退出:")
            if ins=='1':
                self.create_account()
            elif ins=='2':
                choice_type=input("1.员工查询;2.职位查询:")
                if choice_type=='1':
                    self.search_employee()
                elif choice_type=='2':
                    self.search_position()
            elif ins=='3':
                self.upgrade()
            elif ins=='4':
                self.downgrade()
   
    #检查是否存在工号
    def check_uid(self):
        uid=int(input("请输入工号:"))
        while not self.members.get(uid):
            uid=int(input("工号不存在,请重新输入:"))
        return uid
   
    #原等级->新等级
    #升级
    def change_upgrade(self,job,grade):
        add_grade=int(input("请输入需要增加的级数:"))
        if job=='E':
            if grade+add_grade<=10:
                grade+=add_grade
                new_job_grade=job+str(grade)
            elif grade+add_grade<16:
                job='T'
                grade=1
                new_job_grade=job+str(grade)
                self.numberT+=1
                self.numberE-=1
            else:
                print("员工升级请谨慎考虑！！！")
        elif job=='T':
            if grade+add_grade<=6:
                grade+=add_grade
                new_job_grade=job+str(grade)
            else:
                job='M'
                grade=1
                new_job_grade=job+str(grade)
                self.numberM+=1
                self.numberT-=1
        else:
            grade+=add_grade
            while grade+add_grade>3:
                add_grade=int(input("已超过最高等级,请重新输入:"))
            new_job_grade=job+str(grade)
        return new_job_grade,job,grade
    #降级
    def change_downgrade(self,job,grade):
        down_grade=int(input("请输入需要减少的级数:"))
        if job=='E':
            if 0<grade-down_grade:
                grade-=down_grade
                new_job_grade=job+str(grade)
            else:
                while grade-down_grade<=0:
                    down_grade=input("已低于最低等级,请重新输入:")
        elif job=='T':
            if 0<grade-down_grade:
                grade-=down_grade
                new_job_grade=job+str(grade)
            elif grade-down_grade<=0:
                job='E'
                grade=10
                new_job_grade=job+str(grade)
                self.numberE+=1
                self.numberT-=1
        else:
            if 0<grade-down_grade:
                grade-=down_grade
                new_job_grade=job+str(grade)
            elif grade-down_grade<=0:
                job='T'
                grade=6
                new_job_grade=job+str(grade)
                self.numberM-=1
                self.numberT+=1
            else:
                print("员工降级请谨慎考虑！！！")
        return new_job_grade,job,grade
   
    #程序功能：录入员工信息
    def create_account(self):
        name=input("姓名:")
        job=input("职位(E.普通员工;T.组长;M.经理):")
        if job=='E':
            self.numberE+=1
        if job=='T':
            self.numberT+=1
        if job=='M':
            self.numberM+=1
        year=int(input("工龄:"))
        grade=super().is_grade(job)
        salary=super().calculate_salary(job,year,grade)
        member=Umessage(self.uid,name,job,grade,year,salary)
        self.members[self.uid]=member
        print(f"录入成功！姓名{name},工号:{self.uid},薪资:{salary}")
        self.uid+=1

    #程序功能查询：查询员工的信息，职位信息

    #员工查询
    def search_employee(self):
        uid=self.check_uid()
        member=self.members[uid]
        print(f"姓名:{member.name}\n职位:{member.job}\n级别:{member.grade}\n工龄:{member.year}\n薪资:{member.salary}")
    #职位信息
    def search_position(self):
        check_position=input("职位(E.普通员工;T.组长;M.经理):")
        if check_position=='E':
            if self.numberE==0:
                print("目前公司没有普通员工！")
                return
            print(f"目前普通员工共有{self.numberE}人:")
            for k,v in self.members.items():
                if v.job==check_position:
                    print(f"{k} - {v.name}")
        elif check_position=='T':
            if self.numberT==0:
                print("目前公司没有组长！")
                return
            print(f"目前组长共有{self.numberT}人:")
            for k,v in self.members.items():
                if v.job==check_position:
                    print(f"{k} - {v.name}")
        elif check_position=='M':
            if self.numberM==0:
                print("目前公司没有经理！")
                return
            print(f"目前经理共有{self.numberM}人:")
            for k,v in self.members.items():
                if v.job==check_position:
                    print(f"{k} - {v.name}")

    #程序功能：员工升级
    def upgrade(self):
        uid=self.check_uid()
        member=self.members[uid]
        print(f"{member.name},工号:{uid},当前职位:{member.job+str(member.grade)},当前薪资:{member.salary}")
        new_grade,member.job,member.grade=self.change_upgrade(member.job,member.grade)
        salary_0=member.salary
        salary=super().calculate_salary(member.job,member.year,member.grade)
        member.salary=salary
        add_salary=salary-salary_0
        print("升级成功！")
        print(f"{member.name},工号:{uid},升级后的职位:{new_grade},升级后薪资{salary}(+{add_salary})")

    #程序功能：员工降级
    def downgrade(self):
        uid=self.check_uid()
        member=self.members[uid]
        print(f"{member.name},工号:{uid},当前职位:{member.job+str(member.grade)},当前薪资:{member.salary}")
        new_grade,member.job,member.grade=self.change_downgrade(member.job,member.grade)
        salary_0=member.salary
        salary=super().calculate_salary(member.job,member.year,member.grade)
        member.salary=salary
        down_salary=salary_0-salary
        print("升级成功！")
        print(f"{member.name},工号:{uid},升级后的职位:{new_grade},升级后薪资{salary}(-{down_salary})")

def main():
    t=Mange()
    t.welcome()

main()

曾德华

不同的对象，调用同样的方法，最终得到的结果不一样。提现多态

代码简洁，可以灵活添加对象，来调用同一个方法，实现不同的结果

可以

如果它走路像鸭子，叫声像鸭子，那么它就是鸭子。

增加了内聚

不能，这只是一个默认参数的特性

venna

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

g0df1sh

请回复您的答案^_^

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

第 0 题的答案是：
方法重写鸭子类型运算符重载抽象基类函数参数的多态性
第 1 题的答案是：
1. 提高代码的可扩展性2. 增强代码的可维护性3. 提高代码的复用性4. 实现接口统一5. 支持更自然的问题建模6. 提高系统灵活性
第 2 题的答案是：
是的，Python 中 1 + 1 == 2 和 '1' + '1' == '11' 这种根据操作数类型不同而表现出不同行为的现象，可以称为多态的一种体现，更准确地说，这是运算符重载（Operator Overloading）实现的多态，属于特设多态（Ad-hoc Polymorphism）的一种形式。
第 3 题的答案是：
"If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck."
第 4 题的答案是：
软件设计中，鸭子类型（Duck Typing）主要通过降低模块间的耦合度来提升设计质量，同时对内聚性的影响相对中立（甚至可能间接增强内聚）
第 5 题的答案是：
和多态无关，因为：

没有涉及不同对象的行为差异。

没有依赖继承或接口实现。

仅仅是同一个函数对参数数量的灵活处理
-------- 动动手 --------

请将第 0 题的代码写在下方：
class Employee:
    _next_uid = 10000  # 工号从10000开始自动分配

    def __init__(self, name, job, grade, year):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
        self.uid = Employee._next_uid
        Employee._next_uid += 1

    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):
        if self.job == "Employee":
            return 3000 + 500 * self.grade + 50 * self.year
        elif self.job == "Teamleader":
            return 4000 + 800 * self.grade + 100 * self.year
        elif self.job == "Manager":
            return 5000 + 1000 * (self.grade + self.year)

    def promote(self, levels=1):
        max_grade = self._get_max_grade()
        new_grade = self.grade + levels
        
        # 检查是否需要升职
        if new_grade > max_grade:
            if self.job == "Employee":
                self.job = "Teamleader"
            elif self.job == "Teamleader":
                self.job = "Manager"
            self.grade = 1  # 升职后级别重置为1
            return True  # 表示发生了升职
        else:
            self.grade = new_grade
            return False

    def demote(self, levels=1):
        max_grade = self._get_max_grade()
        new_grade = self.grade - levels
        
        # 检查是否需要降职
        if new_grade < 1:
            if self.job == "Manager":
                self.job = "Teamleader"
            elif self.job == "Teamleader":
                self.job = "Employee"
            self.grade = self._get_max_grade()  # 降职后级别设为新职位的最高级
            return True  # 表示发生了降职
        else:
            self.grade = new_grade
            return False

    def _get_max_grade(self):
        if self.job == "Employee":
            return 10
        elif self.job == "Teamleader":
            return 6
        elif self.job == "Manager":
            return 3

    def __str__(self):
        return f"UID: {self.uid}, Name: {self.name}, Job: {self.job}, Grade: {self.grade}, Years: {self.year}, Salary: {self.salary()}"


class EmployeeManagementSystem:
    def __init__(self):
        self.employees = []

    def add_employee(self, name, job, grade, year):
        if job not in ["Employee", "Teamleader", "Manager"]:
            print("Invalid job type!")
            return None
        
        max_grade = 10 if job == "Employee" else (6 if job == "Teamleader" else 3)
        if grade < 1 or grade > max_grade:
            print(f"Invalid grade for {job}! Must be between 1 and {max_grade}.")
            return None
        
        employee = Employee(name, job, grade, year)
        self.employees.append(employee)
        return employee

    def find_by_uid(self, uid):
        for emp in self.employees:
            if emp.get_uid() == uid:
                return emp
        return None

    def find_by_name(self, name):
        return [emp for emp in self.employees if emp.get_name() == name]

    def find_by_job(self, job):
        return [emp for emp in self.employees if emp.get_job() == job]

    def promote_employee(self, uid, levels=1):
        emp = self.find_by_uid(uid)
        if emp:
            return emp.promote(levels)
        return False

    def demote_employee(self, uid, levels=1):
        emp = self.find_by_uid(uid)
        if emp:
            return emp.demote(levels)
        return False

    def list_all_employees(self):
        return self.employees


# 测试代码
if __name__ == "__main__":
    system = EmployeeManagementSystem()
   
    # 添加员工
    system.add_employee("张三", "Employee", 3, 2)
    system.add_employee("李四", "Teamleader", 2, 5)
    system.add_employee("王五", "Manager", 1, 10)
   
    # 查询功能
    print("=== 所有员工 ===")
    for emp in system.list_all_employees():
        print(emp)
   
    print("\n=== 查询工号10000 ===")
    print(system.find_by_uid(10000))
   
    print("\n=== 查询所有经理 ===")
    for emp in system.find_by_job("Manager"):
        print(emp)
   
    # 升级测试
    print("\n=== 升级测试 ===")
    emp = system.find_by_uid(10000)
    print(f"升级前: {emp}")
    system.promote_employee(10000, 8)  # 普通员工3级+8=11级，超过10级，应升为组长1级
    print(f"升级后: {emp}")
   
    # 降级测试
    print("\n=== 降级测试 ===")
    emp = system.find_by_uid(10001)
    print(f"降级前: {emp}")
    system.demote_employee(10001, 3)  # 组长2级-3=-1级，低于1级，应降为普通员工10级
    print(f"降级后: {emp}")

Siriooo

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：
子类可以重写父类的方法
第 2 题的答案是：
可以，对于+来说，前面是做运算，后面是做组合。对于==来说前后都是判断
第 3 题的答案是：
走起路来像鸭子，叫起来像鸭子，它就是鸭子
第 4 题的答案是：
降低了耦合度
第 5 题的答案是：
不是
-------- 动动手 --------

请将第 0 题的代码写在下方：
clerk = []
uid = [999]
class Clerk():
    def __init__(self):
        self.name = input('姓名：')
        self.job = input('职位（E.普通员工；T.组长；M。经理）：')
        self.year = input('工龄：')
        self.grade = input('级别：')
    def get_uid(self):
        # 计算工号
        self.inputuid = uid[-1] + 1
        uid.append(self.inputuid)
        return self.inputuid
    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):
        # 计算薪资
        # 计算级别是否合理
        if self.job == 'e':
            while (int(self.grade) > 10):
                self.grade = input('该职位最高为10，请重新入录级别：')
            self.salary = 3000 + 500 * int(self.grade) + 50 * int(self.year)
        elif self.job == 't':
            while (int(self.grade) > 6):
                self.grade = input('该职位最高为6，请重新入录级别：')
            self.salary = 4000 + 800 * int(self.grade) + 100 * int(self.year)
        elif self.job == 'm':
            while (int(self.grade) > 3):
                self.grade = input('该职位最高为3，请重新入录级别：')
            self.salary = 5000 + 1000 * (int(self.grade) + int(self.year))
        return self.salary
first = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
while(first != '5'):

    if first == '1':
        c1 = Clerk()
        c1.get_uid()
        c1.get_salary()
        print(f"录入成功！姓名：{c1.name} 工号：{c1.inputuid} 薪资：{c1.salary}")
        clerk.append(c1)
        first = input('1.录入；2.查询；3.升级；4.降级；5.退出：')

    elif first == '2':
        secend = input('1.员工查询；2.职位查询')
        if secend == '1':
            uidd = input('请输入工号：')
            a = 1
            for i in clerk:
                if i.inputuid == int(uidd):
                    print('姓名：',i.get_name())
                    print('职位：',i.get_job())
                    print('级别：',i.get_grade())
                    print('工龄：',i.get_year())
                    print('薪资：',i.salary)
                    a = 0
            if a == 1:
                print('该工号不存在！')
        elif secend == '2':
            jobb = input('职位（E.普通员工；T.组长；M。经理）：')
            b = 0
            sum = 0
            for i in clerk:
                if jobb == i.job:
                    print(f"{i.job} ------ {i.get_name()}")
                    sum += 1
                    print('目前共有',sum,'人')
                    b = 1
            if b == 0:
                print('该职位没有员工')
        first = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
    elif first == '3':
        increaseuid = input('请输入工号')
        for i in clerk:
            if i.inputuid == int(increaseuid):
                print(f"{i.name}，工号：{i.inputuid}，"
                      f"当前职位：{i.job}{i.grade}，当前薪资{i.salary}")
                increasegrade = input('请输入需要增加的级数')
                if i.job == 'e':
                    gradesum = 0 + int(i.grade)
                    gradesum = gradesum + int(increasegrade)
                elif i.job == 't':
                    gradesum = 10 + int(i.grade)
                    gradesum = gradesum + int(increasegrade)
                elif i.job == 'm':
                    pasgradesum = 16 + int(i.grade)
                    gradesum = gradesum + int(increasegrade)
                #计算升级后的职位等级
                if gradesum < 11:
                    i.grade = str(gradesum)
                elif gradesum < 17:
                    i.job = 't'
                    i.grade = str(gradesum - 10)
                elif gradesum < 20:
                    i.job = 'm'
                    i.grade = str(gradesum - 16)
                print('升级成功!')
                i.get_salary()
                print(f"{i.name}，工号：{i.inputuid}，"
                      f"升级后职位：{i.job}{i.grade}，"
                      f"升级后薪资{i.salary}")

        first = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
    elif first == '4':
        decreauid = input('请输入工号')
        for i in clerk:
            if i.inputuid == int(decreauid):
                print(f"{i.name}，工号：{i.inputuid}，"
                      f"当前职位：{i.job}{i.grade}，"
                      f"当前薪资{i.salary}")
                decreagrade = input('请输入需要减少的级数')
                if i.job == 'e':
                    gradesum = 0 + int(i.grade)
                    gradesum = gradesum - int(decreagrade)
                elif i.job == 't':
                    gradesum = 10 + int(i.grade)
                    gradesum = gradesum - int(decreagrade)
                elif i.job == 'm':
                    gradesum = 16 + int(i.grade)
                    gradesum = gradesum - int(decreagrade)
                # 计算升级后的职位等级
                if gradesum < 11:
                    i.grade = str(gradesum)
                elif gradesum < 17:
                    i.job = 't'
                    i.grade = str(gradesum - 10)
                elif gradesum < 20:
                    i.job = 'm'
                    i.grade = str(gradesum - 16)
                print('升级成功!')
                i.get_salary()
                print(f"{i.name}，工号：{i.inputuid}，"
                      f"降级后职位：{i.job}{i.grade}，"
                      f"降级后薪资{i.salary}")

        first = input('1.录入；2.查询；3.升级；4.降级；5.退出：')

fafafa2525

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

变西瓜

1
请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

wu55500

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

zhuhanwen123

请回复您的答案^_^

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

第 0 题的答案是：类的封装

第 1 题的答案是：不同对象可以使用相同方法

第 2 题的答案是：可以

第 3 题的答案是：

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

第 5 题的答案是：不属于

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

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

xl1123456789

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

pangzi_zhe

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

brav

请回复您的答案^_^

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

第 0 题的答案是：
只需要对象的方法符合要求，就可以调用
第 1 题的答案是：
使代码更加模块化、易于扩展和维护。
第 2 题的答案是：
可以
第 3 题的答案是：
“如果它走起来像鸭子，叫起来也像鸭子，那么它很可能就是一只鸭子。”
    这句话强调的是行为和接口的重要性，而不是对象的具体类型。
第 4 题的答案是：
鸭子类型增强了低耦合度：通过关注对象的行为而非具体类型，
    鸭子类型减少了模块之间的硬编码依赖，提高了系统的灵活性和可维护性。
    鸭子类型不直接影响内聚性：内聚性主要关注模块内的功能联系，鸭子类
    型更多地帮助实现低耦合，但需要结合良好的设计来实现高内聚。
第 5 题的答案是：
是
-------- 动动手 --------

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

一只co

1

tutu_zhang

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

zkw1225

请回复您的答案^_^

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

第 0 题的答案是：
具有同样名字的方法，可以有不同的作用
第 1 题的答案是：
同样方法不同作用
第 2 题的答案是：
可以
第 3 题的答案是：
bzd
第 4 题的答案是：
低耦合
第 5 题的答案是：
不是
-------- 动动手 --------

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

liujg01

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

是条咸鱼

请回复您的答案^_^

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

第 0 题的答案是：&#8203;&#8203;继承与方法重写&#8203;&#8203;：子类覆盖父类方法。
&#8203;&#8203;鸭子类型&#8203;&#8203;：不依赖继承，只依赖对象的行为。
&#8203;&#8203;运算符重载&#8203;&#8203;：通过特殊方法自定义运算符行为。
&#8203;&#8203;抽象基类&#8203;&#8203;：强制子类实现统一接口。
&#8203;&#8203;动态类型系统&#8203;&#8203;：函数参数和变量无需声明类型，运行时确定行为。

第 1 题的答案是：提高代码的灵活性和可扩展性&#8203;
减少代码重复（DRY 原则）
第 2 题的答案是：可以

第 3 题的答案是：If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck.

第 4 题的答案是：&#8203;&#8203;降低耦合度

第 5 题的答案是：这个例子体现的是 &#8203;&#8203;函数参数默认值（Default Arguments）&#8203;&#8203; 和 &#8203;&#8203;函数重载（Function Overloading）的模拟&#8203;&#8203;，而不是多态（Polymorphism）。



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

请将第 0 题的代码写在下方：class Employee:
    def __init__(self, name, grade, year, uid):
        self.name = name
        self.grade = grade
        self.year = year
        self.uid = uid

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


class TeamLeader(Employee):
    def salary(self):  #
        return 4000 + 800 * self.grade + 100 * self.year


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

python渣渣顺

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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