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

A_KUN

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

小白不急躁

请回复您的答案^_^

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

第 0 题的答案是：
多态本来就是Pyhton本身自身的特性
第 1 题的答案是：
能让函数接收不同的对象作为参数，并且不检查其类型的情况下去执行它的方法
第 2 题的答案是：
可以称之为多态；第一个是整数相关的，第二个是str相关的
python很是顺气自然的执行了
第 3 题的答案是：
那么这个对象即有鸭子的属性又有鸭子的方法
那么这个对象就是鸭子
第 4 题的答案是：
应该是和耦合度有关系降低了耦合度
第 5 题的答案是：
是
-------- 动动手 --------

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

Moiy

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

程同学295

请回复您的答案^_^

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

第 0 题的答案是：
只要调用的函数在类中有定义，无论是否同类，都不会报错
第 1 题的答案是：
一鱼多吃
第 2 题的答案是：
不行
第 3 题的答案是：

第 4 题的答案是：
降低耦合
第 5 题的答案是：
属于
-------- 动动手 --------

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

ajaklfkadfj

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

延陵呆子

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

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

class Member:
    def __init__(self):
        self.get_name()
        self.get_job()
        self.get_year()
        self.get_grade()
    def get_uid(self):
        self.uid = None
    def get_name(self):
        name = input("姓名：")
        self.name = name
    def get_job(self):
        job = input("职位（E.普通员工;T.组长;M.经理）：")
        self.job = job
    def get_grade(self):
        grade = input("级别：")
        panduan = 0
        while panduan == 0:
            if (self.job == 'M') and (int(grade) > 3):
                grade = input("该职位最高级别为3，请重新录入级别：")
            elif (self.job == 'T') and (int(grade) > 6):
                grade = input("该职位最高级别为6，请重新录入级别：")
            elif (self.job == 'E') and (int(grade) > 10):
                grade = input("该职位最高级别为10，请重新录入级别：")
            else:
                panduan = 1
        self.grade = int(grade)
    def get_year(self):
        self.year = int(input("工龄："))
        


class Mixin:
    def grade_up(self,job,gradenow):
        num = int(input("请输入需要增加的级别数："))
        if job == 'M':
            if gradenow + num <= 3:
                grade = gradenow +num
            else:
                grade = 3
            job = 'M'
        elif job == 'T':
            if gradenow +num <= 6:
                job = 'T'
                grade = gradenow +num
            else:
                job = 'M'
                grade = 1
        elif job == 'E':
            if gradenow +num <= 10:
                job = 'E'
                grade = gradenow +num
            else:
                job = 'T'
                grade = 1
        return (job, grade)
    def grade_low(self,job,gradenow):
        num = int(input("请输入需要减少的级别数："))
        if job == 'M':
            if gradenow - num <= 0:
                job = 'T'
                grade = 6
            else:
                grade = gradenow - num
        elif job == 'T':
            if gradenow -num <= 0:
                job = 'E'
                grade = 10
            else:
                job = 'T'
                grade = gradenow - num
        elif job == 'E':
            if gradenow -num <= 0:
                job = 'E'
                grade = 1
            else:
                job = 'E'
                grade = gradenow - num
        return (job, grade)

class Manage(Mixin):
    def __init__(self):
        self.members = {}
        self.cardid = 10000
    def welcome(self):
        while True:
            print("\n")
            ins = input("1.录入;2.查询;3.升级;4.降级;5.退出：")
            if ins == '1':
                self.creat_member()
            if ins == '2':
                self.view()
            if ins == '3':
                self.gradeup()
            if ins == '4':
                self.gradelow()
            if ins == '5':
                break
            
            


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

    def creat_member(self):
        member = Member()
        member.uid = self.cardid
        member.salary = self.salary(member.job,member.grade,member.year)
        self.members[self.cardid] = member
        self.cardid += 1
        print(f"录入成功！姓名：{member.name}，工号：{member.uid}，薪资：{member.salary}")
    def view(self):
        choose = input("1.员工查询；2.职位查询：")
        if choose == '1':
            uid = int(input("请输入工号："))
            if not self.members.get(uid):
                print("该工号不存在：")
            else:
                member = self.members.get(uid)
                print(f"姓名：{member.name}")
                print(f"职位：{member.job}")
                print(f"级别：{member.grade}")
                print(f"工龄:{member.year}")
                print(f"薪资：{member.salary}")
        if choose == '2':
            s = 0
            jihe = []
            job = input("职位（E.普通员工;T.组长;M.经理）：")
            for each in self.members:
                member = self.members.get(each)
                if member.job == job:
                    s += 1
                    jihe.append([member.uid, member.name])
            if job == 'E':
                print(f"目前普通员工有{s}人")
            if job == 'T':
                print(f"目前组长有{s}人")
            if job == 'M':
                print(f"目前经理有{s}人")
            for each in jihe:
                print(f'{each[0]} - {each[1]}')
               
    def gradeup(self):
        uid = int(input("请输入工号："))
        member = self.members.get(uid)
        qianxz = member.salary
        print(f"姓名：{member.name}，工号：{member.uid}，当前职位：{member.job}{member.grade}，当前薪资：{qianxz}")
        member.job, member.grade = self.grade_up(member.job,member.grade)
        member.salary = self.salary(member.job,member.grade,member.year)
        zengjia = member.salary-qianxz
        print("升级成功！")
        print(f"姓名：{member.name}，工号：{member.uid}，升级后职位：{member.job}{member.grade}，升级后薪资：{member.salary}(+{zengjia})")
    def gradelow(self):
        uid = int(input("请输入工号："))
        member = self.members.get(uid)
        qianxz = member.salary
        print(f"姓名：{member.name}，工号：{member.uid}，当前职位：{member.job}{member.grade}，当前薪资：{qianxz}")
        member.job, member.grade = self.grade_low(member.job,member.grade)
        member.salary = self.salary(member.job,member.grade,member.year)
        jianshao = member.salary-qianxz
        print("降级成功！")
        print(f"姓名：{member.name}，工号：{member.uid}，降级后职位：{member.job}{member.grade}，降级后薪资：{member.salary}({jianshao})")

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

cc958

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

延陵呆子

0.
子类对父类的重写
函数的鸭子类型

1.
可以被反复调用，节约空间

2.
可以

3.
不知道

4.
增强了内度
提高了耦合

5.
不是

meimei003851

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

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

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

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

FishLiu

请回复您的答案^_^

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

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

第 1 题的答案是：尽管我们的接口是不变的，但它却可以根据不同的对象执行不同的操作。

第 2 题的答案是：可以

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

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

第 5 题的答案是：不属于吧。。

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

请将第 0 题的代码写在下方：
class Employee:
    def __init__(self, uid, name, job, grade, year):
        self.uid = uid
        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 set_grade(self, grade):
        self.grade = grade

    def get_year(self):
        return self.year

    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)


def main():
    employee = {}
    jobs = {'E': [], 'T': [], 'M': []}
    uid = 10000
    max_e = 10
    max_t = 6
    max_m = 3

    while True:
        ins = input("\n1.录入；2.查询；3.升级；4.降级；5.退出：")
        if ins == '1':
            name = input("姓名：")
            job = input("职位（E.普通员工；T.组长；M.经理）：")
            year = int(input("工龄："))
            grade = int(input("级别："))
            if job == "E":
                while grade > max_e:
                    grade = int(input(f"该职位最高级别为{max_e}，请重新录入级别："))

                e = Employee(uid, name, job, grade, year)
                employee[uid] = e
                jobs['E'].append(e)
            if job == "T":
                while grade > max_t:
                    grade = int(input(f"该职位最高级别为{max_t}，请重新录入级别："))

                e = Teamleader(uid, name, job, grade, year)
                employee[uid] = e
                jobs['T'].append(e)
            if job == "M":
                while grade > max_m:
                    grade = int(input(f"该职位最高级别为{max_m}，请重新录入级别："))

                e = Manager(uid, name, job, grade, year)
                employee[uid] = e
                jobs['M'].append(e)

            print(f"录入成功！姓名：{name}，工号：{uid}，薪资：{e.salary()}")
            uid += 1

        if ins == '2':
            finder = input("1.员工查询；2.职位查询：")
            if finder == '1':
                find_uid = int(input("请输入工号："))
                if employee.get(find_uid):
                    e = employee[find_uid]
                    print(f"姓名：{e.get_name()}", f"职位：{e.get_job()}", f"级别：{e.get_grade()}",
                          f"工龄：{e.get_year()}",
                          f"薪资：{e.salary()}", sep="\n")
                else:
                    print("该工号不存在！")
            if finder == '2':
                find_job = input("请输入职位（E.普通员工；T.组长；M.经理）：")
                if find_job == 'E':
                    if jobs['E']:
                        print(f"目前普通员工共有{len(jobs['E'])}人：")
                        for each in jobs['E']:
                            print(f"{each.get_uid()} - {each.get_name()}")
                    else:
                        print("该公司目前没有普通员工！")
                if find_job == 'T':
                    if jobs['T']:
                        print(f"目前普通员工共有{len(jobs['T'])}人：")
                        for each in jobs['T']:
                            print(f"{each.get_uid()} - {each.get_name()}")
                    else:
                        print("该公司目前没有组长！")
                if find_job == 'M':
                    if jobs['M']:
                        print(f"目前普通员工共有{len(jobs['M'])}人：")
                        for each in jobs['M']:
                            print(f"{each.get_uid()} - {each.get_name()}")
                    else:
                        print("该公司目前没有经理！")
        if ins == '3':
            up_uid = int(input("请输入工号："))
            if employee.get(up_uid):
                e = employee[up_uid]
                uid = e.get_uid()
                name = e.get_name()
                job = e.get_job()
                grade = e.get_grade()
                year = e.get_year()
                old_salary = e.salary()
                print(f"{name}，工号：{uid}，当前职位：{job}{grade}，当前薪资：{old_salary}")
                n = int(input("请输入需要增加的级数："))

                if job == 'E':
                    if grade + n > max_e:
                        job = 'T'
                        grade = 1
                        jobs['E'].remove(e)
                        e = Teamleader(uid, name, job, grade, year)
                        jobs['T'].append(e)
                        employee[uid] = e
                    else:
                        e.set_grade(grade + n)
                elif job == 'T':
                    if grade + n > max_t:
                        job = 'M'
                        grade = 1
                        jobs['T'].remove(e)
                        e = Manager(uid, name, job, grade, year)
                        jobs['M'].append(e)
                        employee[uid] = e
                    else:
                        e.set_grade(grade + n)
                elif job == 'M':
                    if grade + n > max_m:
                        print("已达到最高级别！")
                        e.set_grade(max_m)
                    else:
                        e.set_grade(grade + n)

                new_salary = e.salary()
                print("升级成功！")
                print(
                    f"{e.get_name()}，工号：{e.get_uid()}，升级后职位{e.get_job()}{e.get_grade()}，升级后薪资{new_salary}(+{new_salary - old_salary})")
            else:
                print("工号不存在！")

        if ins == '4':
            up_uid = int(input("请输入工号："))
            if employee.get(up_uid):
                e = employee[up_uid]
                uid = e.get_uid()
                name = e.get_name()
                job = e.get_job()
                grade = e.get_grade()
                year = e.get_year()
                old_salary = e.salary()
                print(f"{name}，工号：{uid}，当前职位：{job}{grade}，当前薪资：{old_salary}")
                n = int(input("请输入需要减少的级数："))

                if job == 'E':
                    if grade - n < 1:
                        print("已达到最低级别！")
                        e.set_grade(1)
                    else:
                        e.set_grade(grade - n)
                elif job == 'T':
                    if grade - n < 1:
                        job = 'E'
                        grade = max_e
                        jobs['T'].remove(e)
                        e = Employee(uid, name, job, grade, year)
                        jobs['E'].append(e)
                        employee[uid] = e
                    else:
                        e.set_grade(grade - n)
                elif job == 'M':
                    if grade - n < 1:
                        job = 'T'
                        grade = max_t
                        jobs['M'].remove(e)
                        e = Teamleader(uid, name, job, grade, year)
                        jobs['T'].append(e)
                        employee[uid] = e
                    else:
                        e.set_grade(grade - n)

                new_salary = e.salary()
                print("升级成功！")
                print(
                    f"{e.get_name()}，工号：{e.get_uid()}，升级后职位{e.get_job()}{e.get_grade()}，升级后薪资{new_salary}(-{new_salary - old_salary})")
            else:
                print("工号不存在！")

        if ins == '5':
            break

噩梦症候群

问答题：
0.
重写类的方法
1.
灵活，不用关注对象的类型，根据对象的不同情况输出响应的内容
2.
得到的结果是相同的啊，我觉得可以成为多态
3.
不知道
4.
增强了内聚
5.
不属于

动动手：
0.

miaozai122

请回复您的答案^_^

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

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

pyzzx

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

15278363968

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

格子penbeat

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

suaiguo007

#0 企业员工管理程序


# 会员类：记录会员的关键信息
class Member:
    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 Manage:
    def __init__(self):
        self.members = {}   #初始化self.members是一个空字典，用来存储{uid:Member}
        self.uid = 10000    #初始化self.uid 起始10000
        
    #确认工号，后续功能 需要先 check_uid
    def check_uid(self):
        uid = int(input("请输入工号： "))
        while not self.members.get(uid):
            uid = int(input("该工号不存在! 请输入工号： "))
        return uid    #直到输入正确工号，返回uid

    #程序功能入口
    def welcome(self):
        ins = 0
        print("欢迎使用会员管理系统")
        while ins != 5:
            ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出: ")
            if ins == "1":
                self.create_member()
            if ins == "2":
                self.search_member()
            if ins == "3":
                self.upgrade_member()
            if ins == "4":
                self.degrade_member()
            if ins == "5":
                print("感谢使用会员管理系统")
                break
            
    #程序功能:创建人物
    def create_member(self):
        name = input("姓名： ")
        job = input("职位(E.普通员工;T.组长;M.经理): ")
        while job != "E" and job != "T" and job != "M":         #确认E T M
            job = input("职位(E.普通员工;T.组长;M.经理): ")     
        year = int(input("工龄: "))
        while year < 0:                                         #确认正整数工龄
            year = int(input("不能为负数，请输入工龄: "))
        grade = int(input("级别: "))
        while grade < 0:                                        #确认正整数级别
            grade = int(input("不能为负数，请输入级别: "))

        # 算salary   
        salary = 0        
        if job == "E":
            if 0 < grade <= 10:
                salary = 3000 + 500 * grade + 50 * year
            else:
                while grade <= 0 or grade > 10:
                    grade = int(input("该职位最高级别为10，请重新录入级别: "))
                    salary = 3000 + 500 * grade + 50 * year
        if job == "T":
            if 0 < grade <= 6:
                salary = 4000 + 800 * grade + 100 * year
            else:
                while grade <= 0 or grade > 6:
                    grade = int(input("该职位最高级别为6，请重新录入级别: "))
                    salary = 4000 + 800 * grade + 100 * year
        if job == "M":
            if 0 < grade <= 3:
                salary = 5000 + 1000 * (grade + year)
            else:
                while grade <= 0 or grade > 3:
                    grade = int(input("该职位最高级别为3，请重新录入级别: "))
                    salary = 5000 + 1000 * (grade + year)
        member = Member(self.uid, name, job, grade, year, salary)
        self.members[self.uid] = member
        print(f"录入成功！姓名: {name}, 工号: {self.uid}, 薪资： {salary}")
        print(self.members)
        self.uid += 1

    #程序功能:查询人物
    def search_member(self):
        ins = 0
        
        while ins != "5":            
            ins = input("\n1.工号查询;2.职位查询;5.退出: ")
            
            if ins == "1":
                self.find_uid()
            if ins == "2":
                self.check_job()
            if ins =="5":
                print("已返回上级菜单")
                break
            

    #程序功能:查询人物-工号查询
    def find_uid(self):
        uid = self.check_uid()
        print(f"姓名: {self.members[uid].name}")
        print(f"职位: {self.members[uid].job}")
        print(f"级别: {self.members[uid].grade}")
        print(f"工龄: {self.members[uid].year}")
        print(f"薪资: {self.members[uid].salary}")
      
    #程序功能:查询人物-职位查询
    def check_job(self):
        jobtitle = {"E":"普通员工", "T":"组长", "M":"经理"}     #利用字典的键值对
        ckjob = input("职位(E.普通员工;T.组长;M.经理): ")
        jobnum = 0              #此job中的数量
        jobuid = []             #此job中id列表
        jobname = []            #此job中name列表
        for i in self.members:            
            if self.members[i].job == ckjob:            #遍历self.members列表的下标号，if == ckjob 需查询的job
                jobnum += 1                             #此job中的数量
                jobuid.append(self.members[i].uid)      #此job中id列表
                jobname.append(self.members[i].name)    #此job中name列表
        if jobnum == 0:
            print(f"目前公司没有{jobtitle[ckjob]}!!!")    #利用字典的键值对
        else:
            print(f"目前{jobtitle[ckjob]}共有{len(jobuid)}人： ") #利用字典的键值对, len此job的id数量
            for j in range(len(jobuid)):                #遍历此job中id列表的下标号
                print(jobuid[j],"-",jobname[j])         #打印对应下标号的id - name
        
    #程序功能:升级
    def upgrade_member(self):
        uid = self.check_uid()
        print(f"{self.members[uid].name},工号:{uid} , 当前职位:{self.members[uid].job}{self.members[uid].grade} , 当前薪资: {self.members[uid].salary}")
        oldsalary = self.members[uid].salary
        upnum = int(input("请输入需要增加的级数: "))
        while upnum < 0:
            upnum = int(input("不能为负数，请输入需要增加的级数: "))       #确认输入正整数   
        newgrade = self.members[uid].grade + upnum        
        # E升级            
        if self.members[uid].job == "E":
            if newgrade > 0 and newgrade <= 10:
                self.members[uid].grade = newgrade               
                self.members[uid].salary = 3000 + 500 * self.members[uid].grade + 50 * self.members[uid].year               
            else:               
                self.members[uid].grade = 1
                self.members[uid].job = "T"
                self.members[uid].salary = 4000 + 800 * self.members[uid].grade + 100 * self.members[uid].year
            print("升级成功")
            print(f"{self.members[uid].name},工号:{uid} , 当前职位:{self.members[uid].job}{self.members[uid].grade} , 当前薪资: {self.members[uid].salary}(+{(self.members[uid].salary - oldsalary)})")

        # T升级
        if self.members[uid].job == "T":
            if newgrade > 0 and newgrade <= 6:
                self.members[uid].grade = newgrade               
                self.members[uid].salary = 4000 + 800 * self.members[uid].grade + 100 * self.members[uid].year               
            else:               
                self.members[uid].grade = 1
                self.members[uid].job = "M"
                self.members[uid].salary = 5000 + 1000 * (self.members[uid].grade + self.members[uid].year)
            print("升级成功")
            print(f"{self.members[uid].name},工号:{uid} , 当前职位:{self.members[uid].job}{self.members[uid].grade} , 当前薪资: {self.members[uid].salary}(+{self.members[uid].salary - oldsalary})")
            
        # M升级
        if self.members[uid].job == "M":
            if newgrade > 0 and newgrade <= 3:
                self.members[uid].grade = newgrade               
                self.members[uid].salary = 5000 + 1000 * (self.members[uid].grade + self.members[uid].year)
                print("升级成功")
            else:
                print("要洗块垒，农药琦当老板咯")

        

    #程序功能:降级
    def degrade_member(self):
        uid = self.check_uid()
        print(f"{self.members[uid].name},工号:{uid} , 当前职位:{self.members[uid].job}{self.members[uid].grade} , 当前薪资: {self.members[uid].salary}")
        oldsalary = self.members[uid].salary
        upnum = int(input("请输入需要减少的级数: "))
        while upnum < 0:
            upnum = int(input("不能为负数，请输入需要减少的级数: "))       #确认输入正整数   
        newgrade = self.members[uid].grade - upnum

        # E降级   
        if self.members[uid].job == "E":
            if newgrade > 0 and newgrade <= 10:
                self.members[uid].grade = newgrade               
                self.members[uid].salary = 3000 + 500 * self.members[uid].grade + 50 * self.members[uid].year
                print("降级成功")
            else:               
                print("降过最低数，要炒鱿鱼啦~")      
            print(f"{self.members[uid].name},工号:{uid} , 当前职位:{self.members[uid].job}{self.members[uid].grade} , 当前薪资: {self.members[uid].salary}({(self.members[uid].salary - oldsalary)})")

        # T降级
        if self.members[uid].job == "T":
            if newgrade > 0 and newgrade <= 6:
                self.members[uid].grade = newgrade               
                self.members[uid].salary = 4000 + 800 * self.members[uid].grade + 100 * self.members[uid].year
            else:
                self.members[uid].grade = 10
                self.members[uid].job = "E"
                self.members[uid].salary = 3000 + 500 * self.members[uid].grade + 50 * self.members[uid].year
            print("降级成功")
            print(f"{self.members[uid].name},工号:{uid} , 当前职位:{self.members[uid].job}{self.members[uid].grade} , 当前薪资: {self.members[uid].salary}({(self.members[uid].salary - oldsalary)})")

        # M降级
        if self.members[uid].job == "M":
            if newgrade > 0 and newgrade <= 3:
                self.members[uid].grade = newgrade               
                self.members[uid].salary = 5000 + 1000 * (self.members[uid].grade + self.members[uid].year)  
            else:
                self.members[uid].grade = 6
                self.members[uid].job = "T"
                self.members[uid].salary = 4000 + 800 * self.members[uid].grade + 100 * self.members[uid].year
            print("降级成功")
            print(f"{self.members[uid].name},工号:{uid} , 当前职位:{self.members[uid].job}{self.members[uid].grade} , 当前薪资: {self.members[uid].salary}({(self.members[uid].salary - oldsalary)})")


            

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



        
打卡

mzlhandsome

看一下

pythonier

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

15135710508

答案见附件

kfc2012008

请回复您的答案^_^

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

第 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 题的代码写在下方：
class Members:
    def __init__(self,name,job,year,uld,grade):
       self.name = name
       self.job  = job
       self.year = year
       self.uld  = uld
       self.grade = grade
       self.x = 0
       self.y = 0
       self.z = 0
    def get_uid(self):
        return self.uld
    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):
        return self.x+self.y*self.grade+self.z*self.year
class Employee(Members):
     def __init__(self,name,job,year,uld,grade):
          Members.__init__(self,name,job,year,uld,grade)
          self.x = 3000
          self.y = 500
          self.z = 50
class Teamleader(Members):
     def __init__(self,name,job,year,uld,grade):
          Members.__init__(self,name,job,year,uld,grade)
          self.x = 4000
          self.y = 800
          self.z = 100
class Manager(Members):
     def __init__(self,name,job,year,uld,grade):
          Members.__init__(self,name,job,year,uld,grade)
          self.x = 5000
          self.y = 1000
          self.z = 1000
class Manage:
    def  __init__(self):
        self.uld = 10000
        self.members = {}
        self.Employee = {}
        self.Teamleader ={}
        self.Manager = {}
    def c_grade(self,job,grade):
        if job == "E":
            while True:
                 if grade <= 10:
                     return grade
                 else:
                     grade =int(input("该职位最高级别为10，请重新录入级别："))

        elif job == "T":
            while True:
                 if grade <= 6:
                     return grade
                 else:
                     grade =int(input("该职位最高级别为6，请重新录入级别："))

        elif job == "M":
            while True:
                 if grade <= 3:
                     return grade
                 else:
                     grade =int(input("该职位最高级别为3，请重新录入级别："))
                                
    def c_job(self,name,job,year,uld,grade):
        if job == "E":
            return Employee(name,job,year,uld,grade)

        elif job == "T":
            return Teamleader(name,job,year,uld,grade)

        elif job == "M":
            return Manager(name,job,year,uld,grade)
        
    def  m_1(self):
        while True:
          n = input("\n1.录入;2.查询;3.升级;4.降级;5.退出:")
          if n == "1":
              self.in_p()
          elif n == "2":
              self.c_x()
          elif n == "3":
              self.up_job()
          elif n == "4":
              self.down_job()
          elif n == '5':
              break
    def in_p(self):
        name = input("姓名：")
        job = input("职位(E.普通员工;T.组长;M.经理):")
        year = int(input("工龄："))
        grade = int(input("级别："))
        grade = self.c_grade(job,grade)
        members_1 = self.c_job(name,job,year,self.uld,grade)
        self.members[self.uld] = members_1
        salary = members_1.salary()
        print(f"录入成功！姓名：{name},工号：{self.uld}，薪资：{salary}")
        self.uld = self.uld + 1
    def ex_job(self,x):  #转换名称
        if x == "E":
            return "普通员工"
        elif x == "T":
            return "组长"
        elif x == "M":
            return "经理"
    def c_x(self):
        n = input("1.员工查询；2.职位查询")
        if n == "1":
            uld = int(input("请输入工号"))
            if self.members.get(uld):
               print(f"姓名：{self.members[uld].name}\n职位：{self.members[uld].job}\n级别：{self.members[uld].grade}\n薪资：{self.members[uld].salary()}")
        
            else:
               print("该工号不存在")
        elif n == "2":
            job = input("职位(E.普通员工;T.组长;M.经理):")
            n = 0
            list_1 = []
            for each in self.members:
                 if self.members[each].job == job:
                     n = n + 1
                     list_1.append(f"{self.members[each].uld} - {self.members[each].name}")
  
            if n == 0:
               print(f"目前公司没有{self.ex_job(job)}")
            else:
               print(f"目前共有{self.ex_job(job)}{n}人。")
               for each in list_1:
                   print(each)
    def up_job(self):
        uld = int(input("请输入工号："))
        if  self.members.get(uld):
            print(f"{self.members[uld].name},工号：{uld}，当前职位：{self.members[uld].job}{self.members[uld].grade},薪资：{self.members[uld].salary()}")
            ex_grade = int(input("请输入增加级数："))
            old_pay = self.members[uld].salary()
            new_grade = self.members[uld].grade + ex_grade
            if self.members[uld].job == "E":
                    if new_grade <= 10:
                       self.members[uld].grade =  new_grade
                    else:
                        self.members[uld] = Teamleader(self.members[uld].name,"T",self.members[uld].year,uld,1)
                  
            elif self.members[uld].job == "T":
                   if new_grade <= 6:
                        self.members[uld].grade =  new_grade
                   else:
                        self.members[uld] = Manager(self.members[uld].name,"M",self.members[uld].year,uld,1)

            elif self.members[uld].job == "M":
                   if new_grade <= 3:
                       self.members[uld].grade =  new_grade
                   else:
                        self.members[uld].grade =  3
                        print("已达最高")
            new_pay = self.members[uld].salary()
            change_pay =  new_pay - old_pay
            print("升级成功！")
            print(f"{self.members[uld].name},工号：{uld}，当前职位：{self.members[uld].job}{self.members[uld].grade},升级后薪资：{self.members[uld].salary()}(+{change_pay})")
        
    def down_job(self):
         uld = int(input("请输入工号："))
         if  self.members.get(uld):
            print(f"{self.members[uld].name},工号：{uld}，当前职位：{self.members[uld].job}{self.members[uld].grade},薪资：{self.members[uld].salary()}")
            ex_grade = int(input("请输入减少级数："))
            old_pay = self.members[uld].salary()
            new_grade = self.members[uld].grade - ex_grade
            if self.members[uld].job == "E":
                    if new_grade >= 1:
                       self.members[uld].grade =  new_grade
                    else:
                        print("已达最低")
                        self.members[uld].grade =  1
                       
            elif self.members[uld].job == "T":
                   if new_grade >= 1:
                       self.members[uld].grade =  new_grade
                   else:
                        self.members[uld] = Employee(self.members[uld].name,"E",self.members[uld].year,uld,10)
            
            elif self.members[uld].job == "M":
                   if new_grade >= 1 :
                       self.members[uld].grade =  new_grade
                   else:
                        self.members[uld] = Teamleader(self.members[uld].name,"T",self.members[uld].year,uld,6)
            new_pay = self.members[uld].salary()
            change_pay = old_pay - new_pay
            print("降级级成功！")
            print(f"{self.members[uld].name},工号：{uld}，当前职位：{self.members[uld].job}{self.members[uld].grade},降级后薪资：{self.members[uld].salary()}(-{change_pay})")

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

main()