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

liujiezheng

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

1010025290

请回复您的答案^_^

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

第 0 题的答案是：  不用关心对象的具体类型，只关心对象是否有相同方法 就可以用同一的接口进行调用
第 1 题的答案是： 不用关心对象的具体类型，只关心对象是否有相同方法 就可以用同一的接口进行调用
第 2 题的答案是：不可以 一个是运算的方法 一个是累加的方法

第 3 题的答案是：不到啊

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

第 5 题的答案是：不属于

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

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

EASEAS

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

mtcy123

请回复您的答案^_^

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

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

第 1 题的答案是：这种 “见机行事” 的行为，我们就称之为多态。

第 2 题的答案是：可以

第 3 题的答案是：When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.

第 4 题的答案是：低耦合

第 5 题的答案是：

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

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

EL-DLG

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

    def create_member(self):
        uid = self.get_uid()
        name = self.get_name()
        job = self.get_job()
        year = self.get_year()
        grade = self.get_grade(job)
        self.members[uid] = Member(name,job,grade,year,uid)
        print(f"录入成功！姓名：{name},工号：{uid}，薪资{self.salary(uid)}")
        
    def query(self):
        ins = 0
        while ins not in ('1','2'):
            ins = input("1.员工查询;2.职位查询：")
            
        if ins == '1':
            self.employee_query()
        if ins == '2':
            self.position_query()
            
    def employee_query(self):
        uid = self.confirm()
        if uid:
                print(f"""
姓名：{self.members[uid].name}
职位：{self.members[uid].job}
级别：{self.members[uid].grade}
工龄：{self.members[uid].year}
薪资：{self.salary(uid)}
""".strip('\n'))
               
    def position_query(self):
        job = self.get_job()
        text = [f"{n.uid} - {n.name}" for n in self.members.values() if n.job == job]
        k = {'E':"普通员工",'T':"组长",'M':"经理"}
        if len(text):
            print(f"目前{k[job]}共有{len(text)}人：\n{"\n".join(text)}")
        else:
            print(f"目前公司没有{k[job]}!")
            
    def upgrade(self):
        text = {'E':10 ,'T':6 ,'M':3 }
        uid = self.confirm()
        if not uid:
            return None
        ord_salary = self.salary(uid)
        print(f"{self.members[uid].name}，工号：{uid}，当前职位：{self.members[uid].job}{self.members[uid].grade}，当前薪资：{self.salary(uid)}")
        level_up = int(input("请输入需要增加的级数："))
        level = self.members[uid].grade + level_up
        if level <= text[self.members[uid].job]:
            self.members[uid].grade = level
        elif level > text[self.members[uid].job] and self.members[uid].job != 'M':
            self.members[uid].grade = 1
            if self.members[uid].job == 'E':
                self.members[uid].job = 'T'
            if self.members[uid].job == 'T':
                self.members[uid].job = 'M'
        else:
            print("等级数据异常，升级失败")
            return None
        print(f"{self.members[uid].name}，工号：{uid}，升级后职位：{self.members[uid].job}{self.members[uid].grade}，升级后薪资：{self.salary(uid)}(+{self.salary(uid) - ord_salary})")

    def downgrade(self):
        text = {'E':10 ,'T':6 ,'M':3 }
        uid = self.confirm()
        if not uid:
            return None
        ord_salary = self.salary(uid)
        print(f"{self.members[uid].name}，工号：{uid}，当前职位：{self.members[uid].job}{self.members[uid].grade}，当前薪资：{self.salary(uid)}")
        level_down = int(input("请输入需要减少的级数："))
        level = self.members[uid].grade - level_down
        if level > 0:
            self.members[uid].grade = level
        elif level <= 0 and self.members[uid].job != 'E':
            if self.members[uid].job == 'T':
                self.members[uid].job = 'E'
            if self.members[uid].job == 'M':
                self.members[uid].job = 'T'
            self.members[uid].grade = text[self.members[uid].job]
        else:
            print("等级数据异常，降级失败")
            return None
        print(f"{self.members[uid].name}，工号：{uid}，降级后职位：{self.members[uid].job}{self.members[uid].grade}，降级后薪资：{self.salary(uid)}(-{ord_salary - self.salary(uid)})")

    def confirm(self):
        uid = int(input("请输入工号："))
        if self.members.get(uid):
            return uid
        else :
            print("该工号不存在!")
            
    def get_uid(self):
        uid = self.uid
        self.uid += 1
        return uid
   
    def get_name(self):
        name = input("姓名：")
        return name
   
    def get_job(self):
        job = input("职位（E.普通员工;T.组长;M.经理）：")
        while job not in ('E','T','M'):
            job = input("请输入正确的职位符号：")
        return job
        
    def get_grade(self,job):
        text = {'E':10 ,'T':6 ,'M':3 }
        max_grade = text[job]
        grade = int(input("级别："))
        while not 1 <= grade <= max_grade:
                grade = int(input(f"该职位最高级别为{max_grade}，请重新录入级别："))
        return grade
   
    def get_year(self):
        while True:
            try:
                year = int(input("工龄："))
                if year < 0:
                    raise ValueError
            except ValueError:
               print("请输入正整数")
            else:
                return year
   
    def salary(self,uid):
        text = {'E':3000 + 500 * self.members[uid].grade + 50 * self.members[uid].year,
                'T':4000 + 800 * self.members[uid].grade + 100 * self.members[uid].year,
                'M':5000 + 1000 * (self.members[uid].grade + self.members[uid].year)}
        return text[self.members[uid].job]
        
    def welcome(self):
        ins = 0
        while ins != '5':
            ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
            if ins == '1':
                self.create_member()
            if ins == '2':
                self.query()
            if ins == '3':
                self.upgrade()
            if ins == '4':
                self.downgrade()
   
def main():
    m = Manage()
    m.welcome()
main()

余宏伟

请回复您的答案^_^

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

第 0 题的答案是：继承和重写

第 1 题的答案是：可扩展性，代码重用，简化复杂性，提高可读性和可维护性

第 2 题的答案是：不能

第 3 题的答案是：看它走起路来像鸭子、叫起来像鸭子，那么它就是鸭子

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

第 5 题的答案是：不属于

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

请将第 0 题的代码写在下方：
class Staff:
    name = ""
    job = ""
    grade = 0
    year = 0
    uid = 10000
    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 set_uid(self):
        self.uid += 1
    def salary(self):
        pass
    def promote(steps):
        pass
    def demote(steps):
        pass
class Employee(Staff):
    def __init__(self, name, job, grade, year, uid):
        super().__init__(name, job, grade, year, uid)
        
    def salary(self):
        return 3000 + 500 * self.grade + 50 * self.year
    def promote(self, steps):
        self.grade += steps
        if self.grade > 10:
            self.job = "TeamLeader"
            self.grade = 1
        print(f"{self.get_name()} promoted to grade {self.get_grade()}")
   
class Teamleader(Staff):
    def __init__(self, name, job, grade, year, uid):
        super().__init__(name, job, grade, year, uid)
        
    def salary(self):
        return 4000 + 800 * self.grade + 100 * self.year
    def promote(self, steps):
        self.grade += steps
        if self.grade > 6:
            self.job = "Manager"
            self.grade = 1
        print(f"{self.get_name()} promoted to grade {self.get_grade()}")
    def demote(self, steps):
        self.grade -= steps
        if self.grade < 1:
            self.job = "Employee"
            self.grade = 10
        print(f"{self.get_name()} demoted to grade {self.get_grade()}")


class Manager(Staff):
    def __init__(self, name, job, grade, year, uid):
        super().__init__(name, job, grade, year, uid)
        
    def salary(self):
        return 5000 + 1000 * (self.grade + self.year)
    def demote(self, steps):
        self.grade -= steps
        if self.grade < 1:
            self.job = "TeamLeader"
            self.grade = 6
        print(f"{self.get_name()} demoted to grade {self.get_grade()}")
class Manage:
    def __init__(self):
        self.staff = []

    def add_staff(self, staff):
        self.staff.append(staff)

    def welcome(self):
        self.staff = []
        self.uid = 10000
        print("Welcome to the Staff Management System")
        for member in self.staff:
            print(f"Name: {member.get_name()}, Job: {member.get_job()}, Salary: {member.salary()}")
def main():
    m = Manage()
    m.welcome()

EL-DLG

请回复您的答案^_^

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

第 0 题的答案是：体现在鸭子类型，不关心是什么，只关心能干什么

第 1 题的答案是：提高代码的可扩展性和可维护性

第 2 题的答案是：可以

第 3 题的答案是：如果它看起来像鸭子，游泳像鸭子，叫声像鸭子，那么它很可能就是鸭子

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

第 5 题的答案是：是

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

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

红红咯

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

卡牌修仙

1请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

laocaiye

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

Niki_Hu

请回复您的答案^_^

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

第 0 题的答案是：
只要符合要求，就能创建一个函数，给出输入，就会给输出。

第 1 题的答案是：
可以简化反复调用相同的方法

第 2 题的答案是：
是的

第 3 题的答案是：
不管是鸡鸭鸟，都是有相同的构造。

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

第 5 题的答案是：
是的

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

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

WangKuKu

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

LJHljh138138

请回复您的答案^_^

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

第 0 题的答案是：通过函数，运算符，对象在不同情节下的不同功能，例如len()计算字符串和列表的情境

第 1 题的答案是：在不同情境下，具有不同的功能


第 2 题的答案是：可以

第 3 题的答案是：不知道

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

第 5 题的答案是：不属于

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

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

第一亿个摸鱼怪

请回复您的答案^_^

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

第 0 题的答案是：
不同类的对象对同一消息（方法调用）做出不同的响应。
第 1 题的答案是：
“一个接口，多种实现”。你不需要关心对象具体是什么类型，只关心它有没有你需要的方法。
第 2 题的答案是：
可以
第 3 题的答案是：
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
第 4 题的答案是：
耦合
第 5 题的答案是：
不是
-------- 动动手 --------

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

LIUQOQ

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

请将第 0 题的代码写在下方：
## 0. 请按要求编写一个企业员工管理程序


class Staff_Init:
    def __init__(self,name,uid,job,year,grade):
        self.name = name
        self.uid = uid
        self.job = job
        self.year = year
        self.grade = grade
    def get_name(self):
        return self.name
    def get_uid(self):
        return self.uid
    def get_job(self):
        return self.job
    def get_year(self):
        return self.year
    def get_grade(self):
        return self.grade
    def get_salary(self):
        if self.job == 'E':
            self.salary = 3000 + 500*self.grade + 50*self.year
        elif self.job == 'T':
            self.salary = 4000 + 800*self.grade + 100*self.year
        elif self.job == 'M':
            self.salary = 5000 + 1000*(self.grade + self.year)
        return self.salary

class Employee(Staff_Init):
    def __init__(self,name,uid,job,year,grade):
        super().__init__(name,uid,job,year,grade)

class Teamleader(Staff_Init):
    def __init__(self,name,uid,job,year,grade):
        super().__init__(name,uid,job,year,grade)

class Manager(Staff_Init):
    def __init__(self,name,uid,job,year,grade):
        super().__init__(name,uid,job,year,grade)

class checkMixin:
    def check_job(self,job):
        while job != 'E' and job != 'T' and job != 'M':
            job = input('请输入正确的职位代号(E.普通员工;T.组长;M.经理):')
        return job

    def check_grade(self,grade,job):
        while True:
            if grade.isnumeric():
                grade = int(grade)
                if job == 'E':
                    if grade <= 10:
                        break
                    else:
                        grade = input('最高级别为10，请重新录入级别:')
                elif job == 'T':
                    if grade <= 6:
                        break
                    else:
                        grade = input('最高级别为6，请重新录入级别:')
                else:
                    if grade <= 3:
                        break
                    else:
                        grade = input('最高级别为3，请重新录入级别:')
            else:
                grade = input('请输入数字:')
        return grade

    def check_number(self,string):
        while not string.isnumeric():
            string = input('请输入数字:')
        return int(string)
   
class changeMixin:
    def change_upgrade(self,job,grade,upgrade):
        if job == 'E':
            grade_new = grade + upgrade
            if grade_new>10:
                return 'T', 1
            else:
                return 'E', grade_new
        if job == 'T':
            grade_new = grade + upgrade
            if grade_new>6:
                return 'M', 1
            else:
                return 'T', grade_new
        if job == 'M':
            grade_new = grade + upgrade
            if grade_new>3:
                return 'M', 3
            else:
                return 'M', grade_new

    def change_downgrade(self,job,grade,downgrade):
        if job == 'E':
            grade_new = grade - downgrade
            if grade_new<=0:
                return 'E', 1
            else:
                return 'E', grade_new
        if job == 'T':
            grade_new = grade - downgrade
            if grade_new<=0:
                return 'E', 10
            else:
                return 'T', grade_new
        if job == 'M':
            grade_new = grade - downgrade
            if grade_new<=0:
                return 'T', 6
            else:
                return 'M', grade_new

class Mune(checkMixin,changeMixin):
    number = 10000
    staffs = {}

    def welcome(self):
        ins = 0
        while ins != '5':
            ins = input('\n1.录入；2.查询；3.升级；4.降级；5.退出：')
            if ins == '1':
                self.creat_staff()
            if ins == '2':
                self.check_staff()
            if ins == '3':
                self.upgrade_staff()
            if ins == '4':
                self.downgrade_staff()

    def creat_staff(self):
        name = input('姓名：')
        uid = Mune.number
        Mune.number += 1
        job = self.check_job(input('职位（E.普通员工;T.组长;M.经理）：'))
        grade = self.check_grade(input('级别：'),job)
        year = self.check_number(input('工龄：'))
        if job == 'E':
            self.staffs[uid] = Employee(name,uid,job,year,grade)
        elif job == 'T':
            self.staffs[uid] = Teamleader(name,uid,job,year,grade)
        elif job == 'M':
            self.staffs[uid] = Manager(name,uid,job,year,grade)
        print(f'录入成功！姓名：{name}，工号：{uid}，薪资：{self.staffs[uid].get_salary()}')

    def check_staff(self):
        ins = input('1.员工查询;2.职位查询;输入其他退出：')
        if ins == '1':
            uid = self.check_number(input('卡号：'))
            if uid>9999 and uid<Mune.number:
                print(f'姓名：{self.staffs[uid].name}')
                print(f'职位：{self.staffs[uid].job}')
                print(f'级别：{self.staffs[uid].grade}')
                print(f'工龄：{self.staffs[uid].year}')
                print(f'薪资：{self.staffs[uid].get_salary()}')
            else:
                print('改工号不存在！')
        elif ins == '2':
            job = self.check_job(input('职位（E.普通员工;T.组长;M.经理）：'))
            count_staffs = [i for i in self.staffs.values() if i.job == job]
            if job == 'E':
                print(f'目前普通员工共有{len(count_staffs)}人')
            elif job == 'T':
                print(f'目前组长共有{len(count_staffs)}人')
            elif job == 'M':
                print(f'目前经理共有{len(count_staffs)}人')
            for i in count_staffs:
                print(f'{i.uid} - {i.name}')

    def upgrade_staff(self):
        uid = self.check_number(input('卡号：'))
        if uid < Mune.number and uid > 9999:
            name = self.staffs[uid].name
            job, grade = self.staffs[uid].job, self.staffs[uid].grade
            year = self.staffs[uid].year
            salary1 = self.staffs[uid].get_salary()
            print(f'{name}，工号：{uid}，当前职位：{job}{grade}，当前薪资：{salary1}')

            upgrade = self.check_number(input('请输入需要增加的级数：'))
            job, grade = self.change_upgrade(job,grade,upgrade)
            if job == 'E':
                self.staffs[uid] = Employee(name,uid,job,year,grade)
            elif job == 'T':
                self.staffs[uid] = Teamleader(name,uid,job,year,grade)
            elif job == 'M':
                self.staffs[uid] = Manager(name,uid,job,year,grade)
            salary2 = self.staffs[uid].get_salary()
            print('升级成功！')
            print(f'{name}，工号：{uid}，升级后职位{job}{grade}，升级后薪资{salary2}(增加{salary2-salary1})')
        else:
            print('卡号不存在！')

    def downgrade_staff(self):
        uid = self.check_number(input('卡号：'))
        if uid < Mune.number and uid > 9999:
            name = self.staffs[uid].name
            job, grade = self.staffs[uid].job, self.staffs[uid].grade
            year = self.staffs[uid].year
            salary1 = self.staffs[uid].get_salary()
            print(f'{name}，工号：{uid}，当前职位：{job}{grade}，当前薪资：{salary1}')

            downgrade = self.check_number(input('请输入需要减少的级数：'))
            job, grade = self.change_downgrade(job,grade,downgrade)
            if job == 'E':
                self.staffs[uid] = Employee(name,uid,job,year,grade)
            elif job == 'T':
                self.staffs[uid] = Teamleader(name,uid,job,year,grade)
            elif job == 'M':
                self.staffs[uid] = Manager(name,uid,job,year,grade)
            salary2 = self.staffs[uid].get_salary()
            print('降级成功！')
            print(f'{name}，工号：{uid}，降级后职位{job}{grade}，降级后薪资{salary2}(减少{salary1-salary2})')
        else:
            print('卡号不存在！')


def main():
    mune = Mune()
    mune.welcome()

main()

zyh00788

请回复您的答案^_^

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

第 0 题的答案是：
多态在编程中是一个非常重要的概念，它是指同一个运算符、函数或对象在不同的场景下，具有不同的作用效果

第 1 题的答案是：
不需要关心对象具体是什么类型，只在乎它的行为方法是否符合要求即可。
第 2 题的答案是：
可以
第 3 题的答案是：
When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck.
第 4 题的答案是：
降低了耦合度
第 5 题的答案是：
属于
-------- 动动手 --------

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

kumu27

请回复您的答案^_^

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

第 0 题的答案是：
对于不同的对象，都能按照方法输出
第 1 题的答案是：
同一段代码多个对象都能使用
第 2 题的答案是：
不是，是运算符重载
第 3 题的答案是：
如果它看起来像鸭子、游泳像鸭子、叫声像鸭子，那么它很可能就是一只鸭子。
第 4 题的答案是：
低耦合
第 5 题的答案是：
不属于
-------- 动动手 --------

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

奇怪的名字

请回复您的答案^_^

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

第 0 题的答案是：同一个方法不同的结果

第 1 题的答案是：优雅

第 2 题的答案是：可以

第 3 题的答案是：鸭子

第 4 题的答案是：内聚

第 5 题的答案是：不属于
-------- 动动手 --------

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

class Employee:
    def salary(self,grade,year):
        return 3000+500*int(grade)+50*int(year)
    def get_grade(self):
        grade=input('your grade')
        while True:
         try:
             if int(grade)>10:
                 int('q')
             break
         except ValueError:
             grade=input('重新输入')
        return grade
class Teamleader:
    def salary(self,grade,year):
        return 4000+800*int(grade)+100*int(year)
    def get_grade(self):
        grade=input('your grade')
        while True:
         try:
             if int(grade)>6:
                 int('q')
             break
         except ValueError:
             grade=input('重新输入')
        return grade


class Manager:
    def salary(self,grade,year):
        return 5000+1000*(int(grade)+int(year))
    def get_grade(self):
        grade=input('your grade')
        while True:
         try:
             if int(grade)>3:
                 int('q')
             break
         except ValueError:
             grade=input('重新输入')
        return grade

class Worker:
    def __init__(self):
     self.member={}
     self.card=10000
     self.cat={'E':10,'T':6,'M':3}
    def get_uid(self):
        return self.card
    def get_name(self):
        name=input('your name')
        return name
    def get_job(self):
        job=input('your job(E普通员工，T组长，M经理')
        while job not in ['M','T','E']:
            job = input('your job(E普通员工，T组长，M经理')
        return job

    def get_year(self):
        year=input('your year')
        while True:
            try:
                int(year)
                break
            except ValueError:
                year = input('重新输入')
        return year
    def lot(self,card,s):
        e = Employee()
        t = Teamleader()
        m = Manager()
        if s == 'E':
            return e.get_grade()
        elif s == 'T':
            return t.get_grade()
        elif s == 'M':
            return m.get_grade()

    def many(self,card,s):
        e=Employee()
        t=Teamleader()
        m=Manager()
        if s=='E':
            return e.salary(self.member[card].grade,self.member[card].year)
        elif s=='T':
            return t.salary(self.member[card].grade, self.member[card].year)
        elif s=='M':
            return m.salary(self.member[card].grade, self.member[card].year)
    def introduce(self,cardid):
        while True:
         try:
          if int(cardid) in self.member:
              d = self.member[int(cardid)]
              print(f'名字{d.name}\n职位{d.job}\n级别{d.grade}\n工龄{d.year}\n工资{self.many(int(cardid), d.job)}')
              break
          else:
              print('该卡号不存在')
         except ValueError:
            print('重新输入一个数字')
    def main(self):
        x=0
        while x!='5':
            x=input('1录入2查询3升级4降级5退出')
            if x=='1':
                name=self.get_name()
                job=self.get_job()
                year=self.get_year()
                card=self.get_uid()
                grade = self.lot(card,job)
                self.member[card]=Member(card,name,job,grade,year)
                print(f'完成了,卡号是{self.card}')
                self.card+=1


            elif x=='2':
                y=0

                who=input('1.员工查询 2.职位查询')
                if who=='1':
                    cardid = input('card')
                    self.introduce(cardid)
                elif who=='2':
                    jobe=input('职位（E.普通员工；T.组长；M.经理）')
                    namee={}
                    for i in self.member:
                        if self.member[i].job==jobe:
                            y+=1
                            namee[i]=self.member[i].name

                    if namee:
                        print(f'总共找到了{y}个')
                        [print(f'{self.member[j].name} {j}') for j in namee]
            elif x=='3':
                cardid = input('card')
                self.introduce(cardid)
                simple=input('请输入要增加的级数')
                if simple=='1' and self.member[int(cardid)].grade=='M':
                    print()

w=Worker()
w.main()

2930976079

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

Roysharon2022

请回复您的答案^_^

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

第 0 题的答案是：它允许不同类的对象对同一消息（方法调用）做出不同的响应，Python 的多态主要依赖于其动态类型和鸭子类型的特性

第 1 题的答案是：
提高代码灵活性&#8203;：可以编写适用于多种类型的通用函数，如 animal_sound(animal)。
&#8203;增强可扩展性&#8203;：添加新类时，只要新类遵循已有的接口（如都有 speak方法），无需修改现有函数代码。
&#8203;减少代码冗余&#8203;：通过统一的接口操作不同对象，避免了为每种类型编写重复的逻辑。

第 2 题的答案是：可以的，其中‘+’在这两个操作中扮演的是不一样的功能，第一个是作为运算符号使用，第二个只是将两个字符串合并到一起

第 3 题的答案是：源于“如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子”的理念

第 4 题的答案是：主要还是降低了耦合度

第 5 题的答案是：代码展示了 Python 中函数参数默认值的用法，这并不属于面向对象编程中多态（Polymorphism）&#8203;&#8203; 的典型范畴。

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

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