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

Tracy418

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

请将第 0 题的代码写在下方：class shuxing:
    def __init__(self, uid, name, job, grade, year, money):
        self.uid = uid
        self.name = name      
        self.job = job
        self.grade = grade   
        self.year = year
        self.money = money
        
class Manage:
    def __init__(self):
        self.members = []  
        self.card_number = 10000  # 卡号从10000开始递增

    def create_member(self):
        name = input("请输入名字: ")
        job = input("职位(E.普通员工;T.组长;M:经理) ")
        year = int(input("工龄:"))
        grade = int(input("级别"))
        # 修正级别输入验证时的变量名错误
        if job == 'E':
            while grade > 10:
                grade = int(input("该职位最高级别位10,请重新录入级别:"))
        elif job == 'T':
            while grade > 6:
                grade = int(input("该职位最高级别位6,请重新录入级别:"))
        elif job == 'M':
            while grade > 3:
                grade = int(input("该职位最高级别位3,请重新录入级别:"))
        uid = self.card_number
        self.card_number += 1
        # 根据职位和级别、工龄计算薪资
        if job == 'E':
            money = 3000 + 500 * grade + 50 * year
        elif job == 'T':
            money = 4000 + 800 * grade + 100 * year
        elif job == 'M':
            money = 5000 + 1000 * grade + 1000 * year
        # 创建对象
        member = shuxing(uid, name, job, grade, year, money)
        self.members.append(member)
        print(f"录入成功!姓名 {name},工号{uid},薪资:{money}")
        
    def find_member(self, uid):
        for member in self.members:
            if member.uid == uid:
                return member
        return None
   
    def yuangongchaxun(self):
        uid = int(input("请输入工号: "))
        # 查找会员
        member = self.find_member(uid)
        if not member:
            print("该工号不存在！")
            return
        print(f"姓名:{member.name}")
        print(f"职位:{member.job}")
        print(f"级别:{member.grade}")
        print(f"工龄:{member.year}")
        print(f"薪资:{member.money}")

    def find_zhiwei(self, job):
        result_list = []
        for member in self.members:
            if member.job == job:
                result_list.append(member)
        return result_list if result_list else None

    def zhiweichaxun(self):
        job = input("职位(E.普通员工;T.组长;M.经理):")
        # 调用 find_zhiwei 方法根据职位查找
        members_list = self.find_zhiwei(job)
        if not members_list:
            print("该职位没人！")
            return
        print(f'目前{job}职位共有{len(members_list)}人:')
        for member in members_list:
            print(member.uid, member.name, sep="-")

    def upgrade(self):
        uid = int(input("请输入工号: "))
        member = self.find_member(uid)
        if not member:
            print("该工号不存在！")
            return
        print(f'{member.name},工号{member.uid},当前职位{member.job}{member.grade},当前薪资{member.money}')
        x = int(input("请输入需要增加的级数: "))
        level_list = ['E1','E2','E3','E4','E5','E6','E7','E8','E9','E10','T1','T2','T3','T4','T5','T6','M1','M2','M3']
        current_level = f"{member.job}{member.grade}"
        # 处理升级后的职位级别
        index = level_list.index(current_level)
        new_level = level_list[index + x]
        member.job = new_level[0]
        member.grade = int(new_level[1])
        if member.job == 'E':
            new_money = 3000 + 500 * member.grade + 50 * member.year
        elif member.job == 'T':
            new_money = 4000 + 800 * member.grade + 100 * member.year
        elif member.job == 'M':
            new_money = 5000 + 1000 * member.grade + 1000 * member.year
        money_diff = new_money - member.money
        member.money = new_money
        print(f"{member.name},工号:{member.uid},升职后的职位{member.job}{member.grade},升职后薪资{member.money}(+{money_diff})")

    def downgrade(self):
        uid = int(input("请输入工号: "))
        member = self.find_member(uid)
        if not member:
            print("该工号不存在！")
            return
        print(f'{member.name},工号{member.uid},当前职位{member.job}{member.grade},当前薪资{member.money}')
        x = int(input("请输入需要减少的级数: "))
        level_list = ['E1','E2','E3','E4','E5','E6','E7','E8','E9','E10','T1','T2','T3','T4','T5','T6','M1','M2','M3']
        current_level = f"{member.job}{member.grade}"
        index = level_list.index(current_level)
        new_level = level_list[index - x]
        member.job = new_level[0]
        member.grade = int(new_level[1])
        if member.job == 'E':
            new_money = 3000 + 500 * member.grade + 50 * member.year
        elif member.job == 'T':
            new_money = 4000 + 800 * member.grade + 100 * member.year
        elif member.job == 'M':
            new_money = 5000 + 1000 * member.grade + 1000 * member.year
        money_diff = member.money - new_money
        member.money = new_money
        print(f"{member.name},工号:{member.uid},降级后的职位{member.job}{member.grade},降级后薪资{member.money}(-{money_diff})")
        

# 主程序入口
def main():
    manager = Manage()
    while True:
        choice = input("\n1.录入;2.查询;3.升级;4.降级;5.退出:")
        if choice == '1':
            manager.create_member()
        elif choice == '2':
            sub_choice = input('1.员工查询;2.职位查询:')
            if sub_choice == '1':
                manager.yuangongchaxun()
            elif sub_choice == '2':
                manager.zhiweichaxun()
        elif choice == '3':
            manager.upgrade()
        elif choice == '4':
            manager.downgrade()
        elif choice == '5':
            print("退出程序")
            break
        else:
            print("无效操作，请重新选择！")

if __name__ == "__main__":
    main()

artificialI

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

ufopro

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

Gyoushinn

请回复您的答案^_^

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

第 0 题的答案是：
同一个函数，作用在不同类型的对象上，结果不同
第 1 题的答案是：
只需要新增类，无需修改原代码
第 2 题的答案是：
可以
第 3 题的答案是：
如果它走路像鸭子，叫声像鸭子，那么它就是鸭子
第 4 题的答案是：
降低了耦合
第 5 题的答案是：
属于
-------- 动动手 --------

请将第 0 题的代码写在下方：
def get_uid():
    global uid
    uid += 1
    return uid

def get_name():
    name = input('姓名:')
    while True:
        if name:
            return name
        else:
            name = input("姓名不能为空，请重新输入姓名:")

def get_job():
    job = input('职位(【E.普通员工】【T.组长】【M.经理】:')
    while True:
        if job == 'E' or job == 'T' or job == 'M':
            return job
        else:
            job = input("职位不存在，请重新输入:")

def get_year():
    year = input("工龄:")
    while True:
        if year.isdecimal() and int(year) < 60:
            return int(year)
        else:
            year = input("请输入正确工龄：")

def judge_job(job):
    if job == 'E':
        return "普通员工"
    elif job == 'T':
        return "组长"
    elif job == 'M':
        return "经理"
   
def get_grade(job):
    grade = input("级别:")
    while True:
        if judge_job(job) == '普通员工' and 0 <= int(grade) <= 10:
            return int(grade)
        elif judge_job(job) == '组长' and 0 <= int(grade) <= 6:
            return int(grade)
        elif judge_job(job) == '经理' and 0 <= int(grade) <= 3:
            return int(grade)
        else:
            grade = input("级别不正确，请输入正确级别:")

def salary(job, grade, year):
    if job == "E":
        return 3000 + (500 * grade) + (50 * year)
    elif job == 'T':
        return 4000 + (800 * grade) + (100 * year)
    elif job == 'M':
        return 5000 + 1000 * (grade + year)

class A():
    def __init__(self):
        self.uid = get_uid()
        self.name = get_name()
        self.job = get_job()
        self.year = get_year()
        self.grade = get_grade(self.job)
        self.salary = salary(self.job, self.grade, self.year)
        d[self.uid] = [self.uid, self.name, self.job, self.year, self.grade, self.salary]
        print(f'录入成功！姓名{self.name},工号{self.uid},薪资{self.salary}')


def get1():
    user_get_uid = int(input("请输入工号:"))
    if judge(user_get_uid):
        print(f"姓名:{d[user_get_uid][1]}")
        print(f"职位:{d[user_get_uid][2]}")
        print(f"级别:{d[user_get_uid][4]}")
        print(f"工龄:{d[user_get_uid][3]}")
        print(f"薪资:{d[user_get_uid][5]}")
                     
def judge(uid):
    if uid in d.keys():
        return True
    else:
        print("该工号不存在！")

def get2():
    input_job = get_job()
    job = judge_job(input_job)
    result = [v for v in d.values() if input_job in v[2]]
    if result:
        print(f'目前{job}共有 {len(result)} 人:')
        for i in result:
            print(f'{i[0]} - {i[1]}')
    else:
        print(f"目前该公司没有{job}！")

def levelup():
    user_get_uid = int(input("请输入工号:"))
    if judge(user_get_uid):
        old_salary = d[user_get_uid][5]
        print(f'{d[user_get_uid][1]},工号：{d[user_get_uid][0]},当前职位：{judge_job(d[user_get_uid][2])}{d[user_get_uid][4]},当前薪资:{old_salary}')
        level = int(input("请输入要增加的级数:"))
        judge_grade_up(user_get_uid,level)
        new_salary = salary(d[user_get_uid][2], d[user_get_uid][4], d[user_get_uid][3])
        print(f'升级成功！')
        print(f'{d[user_get_uid][1]},',end="")
        print(f'工号:{d[user_get_uid][0]},',end="")
        print(f'升级后职位:{judge_job(d[user_get_uid][2])}{d[user_get_uid][4]},',end="")
        print(f'升级后薪资{new_salary}(+{new_salary-d[user_get_uid][5]})')
        d[user_get_uid][5] = new_salary
        
        
        
def judge_grade_up(user_get_uid,level):
    grade = d[user_get_uid][4]
    job = d[user_get_uid][2]
    if job == "E":
        if grade + level >= 10:
            d[user_get_uid][2] = 'T'
            d[user_get_uid][4] = grade + level - 10
        else:
            d[user_get_uid][4] = grade + level

    if job == "T":
        if grade + level >= 6:
            d[user_get_uid][2] = 'M'
            d[user_get_uid][4] = grade + level - 6
        else:
            d[user_get_uid][4] = grade + level

    if job == "M":
        d[user_get_uid][4] = grade + level

def leveldown():
    user_get_uid = int(input("请输入工号:"))
    if judge(user_get_uid):
        print(f'{d[user_get_uid][1]},工号：{d[user_get_uid][0]},当前职位：{judge_job(d[user_get_uid][2])}{d[user_get_uid][4]},当前薪资:{old_salary}')
        level = int(input("请输入要减少的级数:"))
        old_salary = d[user_get_uid][5]
        judge_grade_down(user_get_uid,level)
        new_salary = salary(d[user_get_uid][2], d[user_get_uid][4], d[user_get_uid][3])
        print(f'降级成功！')
        print(f'{d[user_get_uid][1]},',end="")
        print(f'工号:{d[user_get_uid][0]},',end="")
        print(f'降级后职位:{judge_job(d[user_get_uid][2])}{d[user_get_uid][4]},',end="")
        print(f'降级后薪资{new_salary}(-{old_salary-new_salary})')
        
        
def judge_grade_down(user_get_uid,level):
    grade = d[user_get_uid][4]
    job = d[user_get_uid][2]
    if job == "E":
        if grade - level < 0:
            d[user_get_uid][4] = 0

    if job == "T":
        if grade - level < 0:
            d[user_get_uid][2] = 'E'
            d[user_get_uid][4] = grade - level + 10
        else:
            d[user_get_uid][4] = grade - level

    if job == "M":
        if grade - level < 0:
            d[user_get_uid][2] = 'T'
            d[user_get_uid][4] = grade - level + 6   
        else:
            d[user_get_uid][4] = grade - level

def main():
    while True:
        user_input = input("1.录入；2.查询；3.升级；4.降级；5.退出:")
        if user_input == '1':
            employee= A()
        if user_input == '2':
            while True:
                user_input2 = input("1.员工查询；2.职位查询：")
                if user_input2 == "1":
                    get1()
                    break
                elif user_input2 == '2':
                    get2()
                    break
                else:
                    user_input2 = input("请输入1或2进行查询:")
        if user_input == '3':
            levelup()
        if user_input == '4':
            leveldown()
        if user_input == '5':
            break
d = {}
uid = 10000
main()

Towns11

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

xixioo110

请回复您的答案^_^

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

第 0 题的答案是：对不同的对象使用不同的方法

第 1 题的答案是：不用重复定义方法

第 2 题的答案是：可以

第 3 题的答案是：不知道

第 4 题的答案是：不知道什么是鸭子类型

第 5 题的答案是：不属于

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

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

蒜泥魚片

请回复您的答案^_^

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

第 0 题的答案是：指同一个运算符、函数或对象在不同的场景下，具有不同的作用效果，这么一个技能

第 1 题的答案是：動態的"見機行事"

第 2 题的答案是：可以，同一個咚惴�，根據前後文不同，發揮出不同作用，這就是多態

第 3 题的答案是：不知道==

第 4 题的答案是：降低耦合度吧，因為鴨子類型使得一個函數能被重用許多次，不必跟類型綁在一起

第 5 题的答案是：不是吧，因為他只是參數有預設值?

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

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

晚意不迟

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

李毅凡

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

Tshirt

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

hlqln

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

play_john

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

阿归

请回复您的答案^_^

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

第 0 题的答案是：传入不同对象，输出结果不同？

第 1 题的答案是：灵活性，扩展性？

第 2 题的答案是：可以

第 3 题的答案是：？？

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

第 5 题的答案是：不属于&#10060;

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

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

    #获取工号
    def get_uid(self):
        return self.uid

    def get_name(self):
        return self.name

    def get_job(self):
        return self.job

    def get_grade(self):
        return self.grade

    def get_year(self):
        return self.year

    def salary(self):
        if self.job == 'E':
            s = 3000+500*self.grade+50*self.year
        elif self.job == 'T':
            s = 4000+800*self.grade+100*self.year
        elif self.job == 'M':
            s = 5000+1000*(self.grade+self.year)
        return s


class ProFunc:
    emps={}
    uid = 10000
    job_dict = dict(E='普通员工',T='组长',M='经理')
    grade_dict = dict(E=10,T=6,M=3)
    level = 'ETM'
    #录入功能
    def creat_emp(self):
        name = input('姓名：')
        job = input('职位（E.普通员工；T.组长；M.经理）:')
        year = int(input('工龄：'))
        grade = int(input('级别：'))
        self.emps[self.uid] = EmpInfo(name,job,grade,year,self.uid)
        print(f'录入成功！姓名：{name}，工号：{self.uid}，薪资：{self.emps[self.uid].salary()}')
        self.uid += 1

    #查询功能
    def search_info(self):
        op_s = input('1.员工查询；2.职位查询：')
        if op_s == '1':
            uid = int(input('请输入工号：'))
            if uid in self.emps:
                e = self.emps[uid]
                print('姓名：{}\n职位：{}\n级别：{}\n工龄：{}\n薪资{}'.\
                      format(e.get_name(),e.get_job(),e.get_grade(),
                             e.get_year(),e.salary()))
            else:
                print('该工号不存在！')
        else:
            _job = input('职位（E.普通员工；T.组长；M.经理）:')
            ls = ''
            for i in self.emps.values():
                if i.job == _job:
                    ls += f'{i.uid}-{i.name} '
            print(f'目前{self.job_dict[_job]}共有{len(ls)}人：\n{ls}')

    #员工升级
    def grade_up(self):
        uid = int(input('请输入工号：'))
        if uid in self.emps:
            e = self.emps[uid]
            print(f'{e.name}，工号：{e.uid}，当前职位：{e.job}{e.grade}，当前薪资：{e.salary()}')
            n = int(input('请输入需要增加的级数：'))
            if e.grade+n > self.grade_dict[e.job]:
               
                if self.level.find(e.job) == 2:
                    self.emps[uid].grade = self.grade_dict[e.job]
                    self.emps[uid].job = e.job
                    print('已经是最高级别')
                else:
                    self.emps[uid].grade = 1
                    self.emps[uid].job = self.level['ETM'.find(e.job)+1]
            else:
                self.emps[uid].grade = e.grade+n
            print(f'{e.name}，工号：{e.uid}，升级后职位：{e.job}{e.grade}，升级后薪资：{e.salary()}')
            
        else:
            print('该工号不存在！')

    #员工降级
    def grade_down(self):
        uid = int(input('请输入工号：'))
        if uid in self.emps:
            e = self.emps[uid]
            print(f'{e.name}，工号：{e.uid}，当前职位：{e.job}{e.grade}，当前薪资：{e.salary()}')
            n = int(input('请输入需要减少的级数：'))
            if e.grade-n <= 0:
               
                if self.level.find(e.job) == 0:
                    self.emps[uid].grade = 1
                    print('已经是最低级别')
                else:
                    self.emps[uid].job = self.level['ETM'.find(e.job)-1]
                    self.emps[uid].grade = self.grade_dict[e.job]
            else:
                self.emps[uid].grade = e.grade-n
            print(f'{e.name}，工号：{e.uid}，降级后职位：{e.job}{e.grade}，降级后薪资：{e.salary()}')
            
        else:
            print('该工号不存在！')
            
    #主菜单功能
    def menu(self):
        op = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
        while op != '5':
            if op == '1':
                self.creat_emp()
            elif op == '2':
                self.search_info()
            elif op == '3':
                self.grade_up()
            elif op == '4':
                self.grade_down()
               
            op = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
        print('结束程序')

def main():
    e = ProFunc()
    e.menu()

main()

圆柚子

请回复您的答案^_^

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

第 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&#160;跟&#160;'1' + '1' == '11'，这种根据操作数类型不同，得到不同结果的现象，可以称为多态吗？
1 + 1&#160;和&#160;'1' + '1'&#160;的现象可以被视为多态，因为它们体现了 “同一运算符对不同类型产生不同行为” 的特性。

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