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

圆柚子

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：不同的对象调用同一个接口，表现出不同的状态

第 2 题的答案是：可以

第 3 题的答案是：走起来像鸭子，游起来像鸭子，叫起来也像鸭子

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

第 5 题的答案是：属于

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

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

dddelicate

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

火柴人618

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

Alan楠

问答题：
0. Python 是如何体现面向对象的多态特性的？
Python 的多态主要通过其动态类型特性（鸭子类型）和方法重写来实现。
鸭子类型（Duck Typing） ：这是 Python 中多态最核心的体现。Python 不关心对象的实际类型，只关心对象是否拥有特定的方法。这意味着只要不同类的对象拥有相同的方法名，就可以在同一个接口下被调用，而无需显式继承或实现接口。
方法重写（Method Overriding） ：子类可以重新定义（覆盖）父类中已有的方法。当通过父类引用调用这个方法时，实际执行的是子类中重写后的方法。这是传统意义上多态的一种表现形式。      

1. 多态的优势是什么？
         
多态（Polymorphism）是面向对象编程（OOP）的三大基本特性之一（封装、继承、多态），它的优势主要体现在以下几个方面：

1.  代码复用性（Code Reusability）：
       多态允许我们编写更通用的代码。例如，在之前的 `make_sound` 函数中，我们不需要为每种动物类型编写一个单独的函数（如 `make_dog_sound`, `make_cat_sound`），而是可以编写一个通用的函数来处理所有具有 `speak` 方法的对象。这大大减少了代码的重复。

2.  灵活性和可扩展性（Flexibility and Extensibility）：
       当需要引入新的类型时，只要新类型遵循相同的接口（即拥有相同的方法），现有的代码就无需修改。例如，如果未来我们引入一个 `Bird` 类，只要它也实现了 `speak` 方法，`make_sound` 函数就能直接处理 `Bird` 对象，而不需要修改 `make_sound` 函数本身。
       这使得系统更容易扩展，因为添加新功能或新类型不会对现有代码造成破坏性影响（开闭原则：对扩展开放，对修改封闭）。

3.  可维护性（Maintainability）：
       由于代码更加通用和模块化，当需要修改或修复某个行为时，通常只需要修改特定类中的实现，而不会影响到使用该接口的其他部分。这降低了维护的复杂性。

4.  降低耦合度（Reduced Coupling）：
       多态使得调用者和被调用者之间的耦合度降低。调用者（如 `make_sound` 函数）不需要知道被调用对象（如 `dog`、`cat`）的具体类型，只需要知道它们能够响应某个特定的消息（如 `speak()`）。这种松散耦合使得系统组件更加独立，更容易测试和替换。

5.  提高抽象性（Increased Abstraction）：
       多态允许我们从更高层次的抽象角度来思考问题，而不是纠结于具体的实现细节。我们可以定义一个通用的行为（如“发出声音”），然后让不同的对象以自己的方式实现这个行为。
        
2. 请问在 Python 中，1+1 == 2 跟 '1' + '1' == '11'，这种根据操作数类型不同，得到不同结果的现象，可以称为多态吗？
1 + 1 和 '1' + '1' 的现象可以被视为多态，因为它们体现了 “同一运算符对不同类型产生不同行为” 的特性。

3. 关于鸭子类型这个名字的来源，有一句谚语，你知道是什么吗？
如果一个对象“走起来像鸭子，叫起来也像鸭子”，那么它就是鸭子。

4. 高内聚低耦合，是判断软件设计好坏的标准。在程序设计中，我们都希望尽可能做到高内聚（内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事，它描述的是模块内的功能联系）和低耦合（耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据）。那么请问，使用鸭子类型，是增强了内聚呢，还是降低了耦合度呢？

在软件设计中，鸭子类型（Duck Typing）主要通过接口抽象降低模块间的耦合度，但在一定程度上也可能间接促进高内聚。

5.请问下面代码的执行结果，是属于 Python 的多态现象吗？
>>> def add(x, y, z = 0):
...     return x + y + z
...
>>> add(2, 3)
5
>>> add(2, 3, 4)
9

这段代码的执行结果不属于 Python 的多态现象。多态是指不同对象通过相同的接口展现出不同的行为，而代码体现的是函数参数默认值。
        
        
动动手：
0. 请按要求编写一个企业员工管理程序。

需要实现的要求：
a. 员工分类：普通员工（Employee）、组长（Teamleader）、经理（Manager）
b. 员工属性：姓名（name）、职位（job）、级别（grade）、工龄（year）、工号（uid）
c. 员工方法：
    - get_uid() -- 获取工号
    - get_name() -- 获取姓名
    - get_job() -- 获取职位
    - get_grade() -- 获取级别
    - get_year() -- 获取工龄
    - salary() -- 统计并返回工资（计算方法如下）
d. 员工工资计算方法：
    - 普通员工：3000 + 500 * 级别 + 50 * 工龄
    - 组长：4000 + 800 * 级别 + 100 * 工龄
- 经理：5000 + 1000 * (级别 + 工龄)

e. 程序功能：
    - 录入员工数据功能（工号自动分配，由 10000 开始）
    - 查询功能，分为员工查询和职位查询（见程序实现截图）
    - 各类员工级别数量如下：
        - 普通员工：10 级
        - 组长：6 级
        - 经理：3 级
    - 升级功能：支持增加多级；当超过当前职位最高级别时，进行升职操作（无论增加多少个级别，只要发生升职，级别一律初始化为 1 级，见程序实现截图）
    - 降级功能：支持减少多级；当超过当前职位最高级别时，进行升职操作（无论减少多少个级别，只要发生降职，级别一律初始化为当前职位最高级别，见程序实现截图）

录入功能实现如下：

查询功能实现如下：Po

程序升降级功能实现如下：


dai代码：
import sys

# 员工基类
class Employee:
    next_uid = 10000

    def __init__(self, name, job, grade, year):
        self.uid = Employee.next_uid
        Employee.next_uid += 1
        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):
        # This method will be overridden by subclasses
        pass

    def __str__(self):
        return (
            f"工号: {self.uid}\n"  # 添加换行符
            f"姓名: {self.name}\n"  # 添加换行符
            f"职位: {self.job}\n"  # 添加换行符
            f"级别: {self.grade}\n"  # 添加换行符
            f"工龄: {self.year}"
        )

# 普通员工类
class RegularEmployee(Employee):
    MAX_GRADE = 10

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

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

# 组长类
class Teamleader(Employee):
    MAX_GRADE = 6

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

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

# 经理类
class Manager(Employee):
    MAX_GRADE = 3

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

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

# 员工数据存储
employees = []

# 录入员工数据功能
def add_employee():
    print("\n--- 录入员工数据 ---")
    name = input("请输入员工姓名: ")
    job_choice = input("请选择员工职位 (E: 普通员工, T: 组长, M: 经理): ")

    try:
        grade = int(input("请输入员工级别: "))
        year = int(input("请输入员工工龄: "))

        if job_choice == 'E':
            if grade > RegularEmployee.MAX_GRADE:
                print(f"普通员工最高级别为 {RegularEmployee.MAX_GRADE}，已自动调整为最高级别。")
                grade = RegularEmployee.MAX_GRADE
            employees.append(RegularEmployee(name, grade, year))
        elif job_choice == 'T':
            if grade > Teamleader.MAX_GRADE:
                print(f"组长最高级别为 {Teamleader.MAX_GRADE}，已自动调整为最高级别。")
                grade = Teamleader.MAX_GRADE
            employees.append(Teamleader(name, grade, year))
        elif job_choice == 'M':
            if grade > Manager.MAX_GRADE:
                print(f"经理最高级别为 {Manager.MAX_GRADE}，已自动调整为最高级别。")
                grade = Manager.MAX_GRADE
            employees.append(Manager(name, grade, year))
        else:
            print("无效的职位选择。")
            return

        print(f"录入成功！姓名：{name}, 工号：{employees[-1].get_uid()}, 薪资：{employees[-1].salary()}")

    except ValueError:
        print("输入无效，请确保级别和工龄为数字。")

# 查询功能
def search_employee():
    print("\n--- 查询员工数据 ---")
    search_choice = input("请选择查询方式 (1: 按工号查询, 2: 按职位查询): ")

    if search_choice == '1':
        try:
            uid = int(input("请输入要查询的员工工号: "))
            found = False
            for emp in employees:
                if emp.get_uid() == uid:
                    print(emp)
                    print(f"工资: {emp.salary()}")
                    found = True
                    break
            if not found:
                print("未找到该工号的员工。")
        except ValueError:
            print("输入无效，请确保工号为数字。")

    elif search_choice == '2':
        job_query = input("请输入要查询的职位 (普通员工, 组长, 经理): ")
        found = False
        print(f"\n--- {job_query} 列表 ---")
        for emp in employees:
            if emp.get_job() == job_query:
                print(emp)
                print(f"工资: {emp.salary()}")
                found = True
        if not found:
            print(f"未找到职位为 {job_query} 的员工。")

    else:
        print("无效的查询方式。")

# 升级功能
def upgrade_employee():
    print("\n--- 员工升级 ---")
    try:
        uid = int(input("请输入要升级的员工工号: "))
        levels = int(input("请输入要增加的级别数: "))
        found = False
        for emp in employees:
            if emp.get_uid() == uid:
                found = True
                current_job = emp.get_job()
                current_grade = emp.get_grade()
                new_grade = current_grade + levels

                promoted = False
                if current_job == "普通员工":
                    if new_grade > RegularEmployee.MAX_GRADE:
                        print("超过普通员工最高级别，进行升职操作。")
                        emp.job = "组长"
                        emp.grade = 1 # 升职后级别初始化为1
                        promoted = True
                    else:
                        emp.grade = new_grade
                elif current_job == "组长":
                    if new_grade > Teamleader.MAX_GRADE:
                        print("超过组长最高级别，进行升职操作。")
                        emp.job = "经理"
                        emp.grade = 1 # 升职后级别初始化为1
                        promoted = True
                    else:
                        emp.grade = new_grade
                elif current_job == "经理":
                    if new_grade > Manager.MAX_GRADE:
                         print("经理已是最高职位，级别已自动调整为最高级别。")
                         emp.grade = Manager.MAX_GRADE
                    else:
                        emp.grade = new_grade

                if promoted:
                    print(f"员工 {emp.get_name()} 已升职为 {emp.get_job()}，当前级别为 {emp.get_grade()}。")
                else:
                    print(f"员工 {emp.get_name()} 级别已更新为 {emp.get_grade()}。")
                break

        if not found:
            print("未找到该工号的员工。")

    except ValueError:
        print("输入无效，请确保工号和级别数为数字。")

# 降级功能
def downgrade_employee():
    print("\n--- 员工降级 ---")
    try:
        uid = int(input("请输入要降级的员工工号: "))
        levels = int(input("请输入要减少的级别数: "))
        found = False
        for emp in employees:
            if emp.get_uid() == uid:
                found = True
                current_job = emp.get_job()
                current_grade = emp.get_grade()
                new_grade = current_grade - levels

                demoted = False
                if current_job == "经理":
                    if new_grade < 1:
                        print("低于经理最低级别，进行降职操作。")
                        emp.job = "组长"
                        emp.grade = Teamleader.MAX_GRADE # 降职后级别初始化为当前职位最高级别
                        demoted = True
                    else:
                        emp.grade = new_grade
                elif current_job == "组长":
                    if new_grade < 1:
                        print("低于组长最低级别，进行降职操作。")
                        emp.job = "普通员工"
                        emp.grade = RegularEmployee.MAX_GRADE # 降职后级别初始化为当前职位最高级别
                        demoted = True
                    else:
                        emp.grade = new_grade
                elif current_job == "普通员工":
                    if new_grade < 1:
                        print("普通员工已是最低职位，级别已自动调整为最低级别。")
                        emp.grade = 1
                    else:
                        emp.grade = new_grade

                if demoted:
                    print(f"员工 {emp.get_name()} 已降职为 {emp.get_job()}，当前级别为 {emp.get_grade()}。")
                else:
                    print(f"员工 {emp.get_name()} 级别已更新为 {emp.get_grade()}。")
                break

        if not found:
            print("未找到该工号的员工。")

    except ValueError:
        print("输入无效，请确保工号和级别数为数字。")

# 主程序循环
def main():
    while True:
        print("\n--- 企业员工管理系统 ---")
        print("1. 录入员工数据")
        print("2. 查询员工数据")
        print("3. 员工升级")
        print("4. 员工降级")
        print("5. 退出")

        choice = input("请输入您的选择: ")

        if choice == '1':
            add_employee()
        elif choice == '2':
            search_employee()
        elif choice == '3':
            upgrade_employee()
        elif choice == '4':
            downgrade_employee()
        elif choice == '5':
            print("退出系统。")
            sys.exit()
        else:
            print("无效的选择，请重新输入。")

if __name__ == "__main__":
    main()

寒冬咚咚

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

PlanY

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

陈家沟帅帅帅

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

tomo777

请回复您的答案^_^

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

第 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 题的代码写在下方：