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

andreahhhhhh

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

谪仙ovo

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

xiehongzhe

请回复您的答案^_^

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

第 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 Company:
    def __init__(self,name,job,grade,year,uid,salary):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
        self.uid = uid
        self.salary = salary

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

class Manage(Company,Salary):
    def __init__(self):
        self.messages = {}
        self.employee = 0
        self.teamleader = 0
        self.manager = 0
        self.uid = 10000
        self.grade_ = {"E":10,"T":6,"M":3}
    def welcome(self):
        while True:
            _ = input("1.录入;2.查询;3.升级;4.降级;5.退出:")
            if _ == "1":
                self.entering()
            if _ == "2":
                self.inquire()
            if _ == "3":
                self.upgrade()
            if _ == "4":
                self.downgrade()
            if _ == "5":
                break

    def grade_amend(self,job):
        grade = int(input("级别："))
        while True:
            if grade > self.grade_[job]:
                grade = int(input(f"职位最高级别为{self.grade_[job]},请重新输入级别:"))
            else:
                break
        return grade
   
    def entering(self):
        name = input("姓名：")
        job = input("职位（E.普通员工；T.组长；M.经理）：")
        year = int(input("工龄："))
        grade = self.grade_amend(job)
        salary = self.count(job,grade,year)
        if job == "E":
            self.employee += 1
        elif job == "T":
            self.teamleader += 1
        elif job == "M":
            self.manager += 1
        company = Company(name,job,grade,year,self.uid,salary)
        self.messages[self.uid] = company
        print(f"录入成功！姓名：{name},工号：{self.uid},薪资:{salary}")
        self.uid += 1

    def inquire(self):
        ins = input("1.员工查询;2.职位查询：")
        if ins == "1":
            x = int(input("请输入工号："))
            if self.messages.get(x) == None:
                print("该工号不存在!")
            else :
                print(f"姓名：{self.messages[x].name}")
                print(f"职位：{self.messages[x].job}")
                print(f"级别:{self.messages[x].grade}")
                print(f"工龄:{self.messages[x].year}")
                print(f"薪资：{self.messages[x].salary}")
        elif ins == "2":
            y = input("职位（E.普通员工；T.组长；M.经理）：")
            if y == "E":
                if self.employee == 0 :
                    print("目前公司没有普通员工！")
                else:
                    print(f"目前普通员工共有{self.employee}人")
                    for each in self.messages.keys():
                        if self.messages[each].job == "E":
                            print(f"{each}-{self.messages[each].name}")
            elif y == "T":
                if self.teamleader == 0:
                    print("目前公司没有组长！")
                else:
                    print(f"目前组长共有{self.teamleader}人")
                    for each in self.messages.keys():
                        if self.messages[each].job == "T":
                            print(f"{each}-{self.messages[each].name}")
            elif y == "M":
                if self.manager == 0:
                    print("目前公司没有经理！")
                else:
                    print(f"目前经理共有{self.manager}人")
                    for each in self.messages.keys():
                        if self.messages[each].job == "M":
                            print(f"{each}-{self.messages[each].name}")
            

    def upgrade(self):
        x = int(input("请输入工号："))
        if self.messages.get(x) == None:
            print("该工号不存在!")
        else :
            print(f"{self.messages[x].name},工号：{x},当前职位:{self.messages[x].job}{self.messages[x].grade},当前薪资:{self.messages[x].salary}")
            old_salary = self.messages[x].salary
            num = int(input("请输入需要增加的级数："))
            if self.messages[x].job == "E":
                if self.messages[x].grade +num <= 10:
                    self.messages[x].grade += num
                else:
                    self.messages[x].grade =1
                    self.messages[x].job = "T"
                    self.employee -= 1
                    self.teamleader += 1
            elif self.messages[x].job == "T":
                if self.messages[x].grade +num <= 6:
                    self.messages[x].grade += num
                else:
                    self.messages[x].grade =1
                    self.messages[x].job = "M"
                    self.teamleader -= 1
                    self.manager += 1
            elif self.messages[x].job == "M":
                if self.messages[x].grade +num <= 3:
                    self.messages[x].grade += num
                else:
                    self.messages[x].grade =3
               
            print("升级成功！")
            self.messages[x].salary = self.count(self.messages[x].job,self.messages[x].grade,self.messages[x].year)
            print(f"{self.messages[x].name},工号：{self.messages[x].uid},升级后职位：{self.messages[x].job}{self.messages[x].grade},升级后薪资:{self.messages[x].salary}(+{self.messages[x].salary-old_salary})")

    def downgrade(self):
        x = int(input("请输入工号："))
        if self.messages.get(x) == None:
            print("该工号不存在!")
        else :
            print(f"{self.messages[x].name},工号：{x},当前职位:{self.messages[x].job}{self.messages[x].grade},当前薪资:{self.messages[x].salary}")
            old_salary = self.messages[x].salary
            num = int(input("请输入需要减少的级数："))
            if self.messages[x].job == "E":
                if self.messages[x].grade - num <= 0:
                    self.messages[x].grade = 1
                else:
                    self.messages[x].grade = self.messages[x].grade - num
                    
            elif self.messages[x].job == "T":
                if self.messages[x].grade - num <= 0:
                    self.messages[x].grade = 10
                    self.messages[x].job = "E"
                    self.employee += 1
                    self.teamleader -= 1
                else:
                    self.messages[x].grade -= num

            elif self.messages[x].job == "M":
                if self.messages[x].grade - num <= 0:
                    self.messages[x].grade = 6
                    self.messages[x].job = "T"
                    self.teamleader += 1
                    self.manager -= 1
                else:
                    self.messages[x].grade -= num
               
            print("降级成功！")
            self.messages[x].salary = self.count(self.messages[x].job,self.messages[x].grade,self.messages[x].year)
            print(f"{self.messages[x].name},工号：{self.messages[x].uid},降级后职位：{self.messages[x].job}{self.messages[x].grade},降级后薪资:{self.messages[x].salary}(-{old_salary-self.messages[x].salary})")
            
def main():
    m = Manage()
    m.welcome()
            

huanggq

请回复您的答案^_^

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

第 0 题的答案是：
同一个接口传入不同参数时返回不同结果
第 1 题的答案是：

第 2 题的答案是：
是的
第 3 题的答案是：

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

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


class User:
    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):
         print("工号：", self.uid)

    def get_name(self):
        print("姓名：",self.name)

    def get_job(self):
        print("职位：",self.job)

    def get_grade(self):
        print("级别：", self.grade)

    def get_year(self):
        print("年限：",self.year)


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



class Employee:
    def grade(self):
        g = int(input("级别："))
        while g > 10 or g < 1:
            print("该级别最低为1级，最高为10级，请重新录入：",end=" ")
            g = int(input())
        return g

class Teamleader:
    def grade(self):
        g = int(input("级别："))
        while g > 6 or g < 1:
            print("该级别最低为1级，最高为6级，请重新录入：", end=" ")
            g = int(input())
        return g


class Manager:
    def grade(self):
        g = int(input("级别："))
        while g > 3 or g < 1:
            print("该级别最低为1级，最高为3级，请重新录入：", end=" ")
            g = int(input())
        return g


class UpMixin:
    def up(self,job,leve):
        x = int(input("输入增加的级数："))
        l = x + leve
        if job == "E":
            if l > 10:
                return "T", 1
            else:
                return "E", l
        if job == "T":
            if l > 6:
                return "M", 1
            else:
                return "T", l
        if job == "M":
            if l > 3:
                return "M", 3
            else:
                return "M", l





class Manger(UpMixin):

    def __init__(self):
        self.user_list = []
        self.uid = 10000
        self.E = Employee()
        self.T = Teamleader()
        self.M = Manager()


    def j(self, x):
        if x == "E":
            return self.E.grade()
        if x == "T":
            return self.T.grade()
        if x == "M":
            return self.M.grade()


    def new_user(self):
        """
        录入员工信息
        :return:
        """
        if len(self.user_list) == 0:
            uid = self.uid
            name = input("姓名：")
            job = input("职位：(E、普通员工  T、组长  M、经理)：")
            grade = self.j(job)
            year = int(input("工龄："))
        else:
            uid = self.user_list[-1].uid +1
            name = input("姓名：")
            job = input("职位：(E、普通员工  T、组长  M、经理)：")
            grade = self.j(job)
            year = int(input("工龄："))

        self.user_list.append(User(uid, name, job, grade, year))
        print(f"录入完成：姓名{name}，工号：{uid}，职位：{job}，等级：{grade}，工龄：{year}，薪资{self.user_list[-1].salary()}")
        print(self.look())

    def look_user(self):
        print("1、员工查询  2、职位查询")
        x = input()
        if x == "1":
            number = int(input("输入工号"))
            found = False
            for i in self.user_list:
                if number == i.uid:
                    i.get_name()
                    i.get_job()
                    i.get_grade()
                    i.get_year()
                    print("薪资：", i.salary())
                    found = True
                    break
            if not found:
                print("员工不存在")
        if x == "2":
            j = input("职位：(E、普通员工  T、组长  M、经理)：")
            j_list = []
            count = 0
            for i in self.user_list:
                if j == i.job:
                    count += 1
                    j_list.append((i.uid,i.name))
            print(f"共有{count}人")
            print(j_list)

    def user_up(self):
        number = int(input("输入工号"))
        found = False
        for i in self.user_list:
            if number == i.uid:
                i.get_name()
                i.get_job()
                i.get_grade()
                i.get_year()
                print("薪资：", i.salary())
                j,g = self.up(i.job, i.grade)
                i.grade = g
                i.job = j
                self.look()
                print("升级后：")
                i.get_name()
                i.get_job()
                i.get_grade()
                i.get_year()
                print("薪资：", i.salary())
                break
        else:
            print("用户不存在")


    def look(self):
        for i in self.user_list:
            print(i.__dict__)


manger = Manger()

while True:
    print("1、录入 2、查看 3、升级 4、降级 5、退出")
    x = input()
    if x == "1":
        manger.new_user()
    if x == "2":
        manger.look_user()

    if x == "3":
        manger.user_up()

    if x == "5":
        break

hilizzie

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

吃饭睡觉想进步

请回复您的答案^_^

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

第 0 题的答案是：Python通过方法重写和鸭子类型实现多态，允许不同类的对象对同一方法做出不同的响应，而不需要显式继承或类型检查。

第 1 题的答案是：多态的优势在于提高代码的灵活性和可扩展性，允许不同对象对同一方法做出不同响应，简化代码逻辑并支持更通用的设计。

第 2 题的答案是：可以

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

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

第 5 题的答案是：不是

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

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

class Employee:
    def __init__(self,name,job,grade,year,uid):
        self.name=name
        self.job=job
        self.grade=grade
        self.year=year
        self.uid=uid
    def salary(self):
        return 3000+500*self.grade+50*self.year
        

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

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

class Manage:
    def __init__(self):
        self.uid=10000
        self.all_Employee={}
        self.E={}
        self.T={}
        self.M={}
    def func(self):
        a=0
        while a!='5':
            a=input("\n1.录入；2.查询；3.升级；4.降级；5.退出：")
            if a=="1":
                self.create()
            if a=='2':
                self.search()
            if a in ("3","4"):
                self.change_grade(a)
            if a=="5":
                break
    def create(self):
        name=input("姓名：")
        job=input("职位（E.普通员工；T.组长；M.经理）：")
        year=int(input("工龄："))
        grade=int(input("级别："))
        if job=="E":
            while grade>10:
                grade=int(input("该职位最高级别为10，请重新录入级别："))
            e=Employee(name,job,grade,year,self.uid)
            s=e.salary()
            self.E[self.uid]=e
        if job=="T":
            while grade>6:
                grade=int(input("该职位最高级别为6，请重新录入级别："))
            e=Teamleader(name,job,grade,year,self.uid)
            s=e.salary()
            self.T[self.uid]=e
        if job=="M":
            while grade>3:
                grade=int(input("该职位最高级别为3，请重新录入级别："))
            e=Manager(name,job,grade,year,self.uid)
            s=e.salary()
            self.M[self.uid]=e
        self.all_Employee[self.uid]=e
        print(f"录入成功！姓名：{name},工号：{self.uid},薪资：{s}")        
        self.uid+=1
    def search(self):
        b=input("1.员工查询；2.职位查询：")
   
        if b=='1':
            uid=int(input("请输入工号"))
            if uid not in self.all_Employee:
                print("该工号不存在！")
            else:
                x=self.all_Employee[uid]
                print(f"姓名：{x.name}\n职位：{x.job}\n级别：{x.grade}\n工龄：{x.year}\n薪资：{x.salary()}")
        if b=='2':
            c=input("职位（E.普通员工；T.组长；M.经理）：")
            if c=="E":
                num=len(self.E)
                if num==0:
                    print("目前公司没有普通员工！")
                else:
                    print(f"目前普通员工有{num}人：")
                for i in self.E:
                    print(f"{i} - {self.E[i].name}")
            if c=="T":
                num=len(self.T)
                if num==0:
                    print("目前公司没有组长！")
                else:
                    print(f"目前普通员工有{num}人：")
                for i in self.T:
                    print(f"{i} - {self.T[i].name}")
            if c=="M":
                num=len(self.M)
                if num==0:
                    print("目前公司没有经理！")
                else:
                    print(f"目前普通员工有{num}人：")
                for i in self.M:
                    print(f"{i} - {self.M[i].name}")
    def change_grade(self,a):
        uid=int(input("请输入工号:"))
        if uid not in self.all_Employee:
            print("该工号不存在！")
        info=self.all_Employee[uid]
        print(f"{info.name},工号：{uid},当前职位：{info.job}{info.grade},当前薪资{info.salary()}")
        rs=info.salary()
        if a=='4':
            dgrade=int(input("请输入需要减少的级数："))
            if info.job=="E":
                if (info.grade-dgrade)<0:
                    ngrade=1
                    e=Employee(info.name,"E",ngrade,info.year,uid)
                    self.E[uid]=e
                else:
                    ngrade=(info.grade-dgrade)
                    e=Employee(info.name,"E",ngrade,info.year,uid)
                    self.E[uid]=e
            if info.job=="T":
                if (info.grade-dgrade)<0:
                    ngrade=10
                    e=Employee(info.name,"E",ngrade,info.year,uid)
                    self.E[uid]=e
                    del self.T[uid]
                else:
                    ngrade=(info.grade-dgrade)
                    e=Teamleader(info.name,"T",ngrade,info.year,uid)
                    self.T[uid]=e
            if info.job=="M":
                if (info.grade-dgrade)<0:
                    ngrade=6
                    e=Teamleader(info.name,"T",ngrade,info.year,uid)
                    self.T[uid]=e
                    del self.M[uid]
                else:
                    ngrade=(info.grade-dgrade)
                    e=Manager(info.name,"M",ngrade,info.year,uid)
                    self.M[uid]=e
            self.all_Employee[uid]=e
            s=e.salary()
            print("降级成功！")
            print(f"{e.name},工号：{uid},降级后的职位：{e.job}{str(e.grade)}，降级后的薪资：{s}({s-rs})")
        if a=='3':
            igrade=int(input("请输入需要增加的级数："))
            if info.job=="E":
                if info.grade+igrade>10:
                    ngrade=1
                    e=Teamleader(info.name,"T",ngrade,info.year,uid)
                    self.T[uid]=e
                    del self.E[uid]
                else:
                    ngrade=info.grade+igrade
                    e=Employee(info.name,info.job,ngrade,info.year,uid)
                    self.E[uid]=e
            if info.job=="T":
                if info.grade+igrade>6:
                    ngrade=1
                    e=Manager(info.name,"M",ngrade,info.year,uid)
                    self.M[uid]=e
                    del self.T[uid]
                else:
                    ngrade=info.grade+igrade
                    e=Teamleader(info.name,info.job,ngrade,info.year,uid)
                    self.T[uid]=e
            if info.job=="M":
                if info.grade+igrade>3:
                    ngrade=3
                    e=Manger(info.name,"M",ngrade,info.year,uid)
                    self.M[uid]=e
                else:
                    ngrade=info.grade+igrade
                    e=Manager(info.name,"M",ngrade,info.year,uid)
                    self.M[uid]=e
            self.all_Employee[uid]=e
            s=e.salary()
            print("升级成功！")
            print(f"{e.name}，工号：{uid}，升级后的职位：{e.job}{str(e.grade)}，升级后的薪资：{s}(+{s-rs})")

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

pyzyd

请回复您的答案^_^

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

第 0 题的答案是：通过继承、方法重写和鸭子类型，实现了面向对象的多态特性

第 1 题的答案是：通过允许不同的对象对同一消息做出不同的响应，提供了代码的灵活性和可扩展性，同时也提高了代码的可重用性、可读性和可维护性。

第 2 题的答案是：不对

第 3 题的答案是：If it walks like a duck and quacks like a duck, then it must be a duck.

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

第 5 题的答案是：不是

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

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

1. 
   
2. class Employee:
   
3.     def __init__(self, name, job, grade, year, uid):
   
4.         self.name = name
   
5.         self.job = job
   
6.         self.grade = grade
   
7.         self.year = year
   
8.         self.uid = uid
   
9.         self.salarys = self.salary()
   
10. 
    
11.     def get_uid(self):
    
12.         return self.uid
    
13. 
    
14.     def get_name(self):
    
15.         print(f"姓名：{self.name}")
    
16. 
    
17.     def get_job(self):
    
18.         print(f"职位：{self.job}")
    
19. 
    
20.     def get_grade(self):
    
21.         print(f"级别：{self.grade}")
    
22. 
    
23.     def get_year(self):
    
24.         print(f"工龄：{self.year}")
    
25. 
    
26.     def get_salary(self):
    
27.         print(f"薪资：{self.salarys}")
    
28. 
    
29.     def salary(self):
    
30.         if self.job == 'E':
    
31.             s = 3000 + 500 * self.grade + 50 * self.year
    
32.         elif self.job == 'T':
    
33.             s = 4000 + 800 * self.grade + 100 * self.year
    
34.         elif self.job == 'M':
    
35.             s = 5000 + 1000 * (self.grade + self.year)
    
36.         return s
    
37. 
    
38. class EmployeeManageSystem:
    
39.     def __init__(self):
    
40.         self.employee_list = []
    
41.         self.grade_dict = {'E': 10, 'T': 6, 'M': 3}
    
42. 
    
43.     def add_employee(self):
    
44.         name = input("姓名：")
    
45.         job = input("职位（E.普通员工;T.组长;M.经理）：")
    
46.         year = int(input("工龄："))
    
47.         grade = int(input("级别："))
    
48. 
    
49.         while grade > self.grade_dict[job]:
    
50.             grade = int(input(f"该职位最高级别为{self.grade_dict[job]}，请重新录入级别："))
    
51.         uid = 10000 + len(self.employee_list)
    
52.         self.employee_list.append(Employee(name, job, grade, year, uid))
    
53.         salary = self.employee_list[-1].salarys
    
54.         print(f"录入成功！姓名：{name}，工号：{uid}，薪资：{salary}")
    
55. 
    
56.     def inquire_employee(self):
    
57.         method = input("1.员工查询;2.职位查询：")
    
58.         if method == "1":
    
59.             inquire_uid = int(input("请输入工号："))
    
60.             for employee in self.employee_list:
    
61.                 if employee.uid == inquire_uid:
    
62.                     employee.get_name()
    
63.                     employee.get_job()
    
64.                     employee.get_grade()
    
65.                     employee.get_year()
    
66.                     employee.get_salary()
    
67.                     break
    
68.             else:
    
69.                 print("该工号不存在！")
    
70. 
    
71.         elif method == "2":
    
72.             job_map = {'E':"普通员工",'T':"组长",'M':"经理"}
    
73.             inquire_job = input("职位（E.普通员工;T.组长;M.经理）：")
    
74.             emps = []
    
75.             for employee in self.employee_list:
    
76.                 if employee.job == inquire_job:
    
77.                     emps.append(employee)
    
78.             print(f"目前{job_map[inquire_job]}共有 {len(emps)} 人：")
    
79.             if emps:
    
80.                 for employee in emps:
    
81.                     print(f"{employee.uid} - {employee.name}")
    
82.             else:
    
83.                 print(f"目前公司没有{job_map[inquire_job]}！")
    
84. 
    
85.     def upgrades(self):
    
86.         upgrade_uid = int(input("请输入工号："))
    
87.         for employee in self.employee_list:
    
88.             if employee.uid == upgrade_uid:
    
89.                 print(f"{employee.name}，工号：{employee.uid}，当前职位：{employee.job}{employee.grade}，当前薪资：{employee.salarys}")
    
90.                 salary = employee.salarys
    
91.                 var_grade = int(input("请输入需要增加的级数："))
    
92.                 employee.grade += var_grade
    
93.                 if employee.grade > self.grade_dict[employee.job]:
    
94.                     employee.grade = 1
    
95.                     if employee.job == 'E':
    
96.                         employee.job = 'T'
    
97.                     elif employee.job == 'T':
    
98.                         employee.job = 'M'
    
99.                 print("升级成功！")
    
100.                 employee.salarys = employee.salary()
     
101.                 print(f"{employee.name}，工号：{employee.uid}，升级后职位：{employee.job}{employee.grade}，升级后薪资：{employee.salarys}（{employee.salarys - salary:+}）")
     
102.                 break
     
103.         else:
     
104.             print("该工号不存在！")
     
105.     def downgrades(self):
     
106.         downgrade_uid = int(input("请输入工号："))
     
107.         for employee in self.employee_list:
     
108.             if employee.uid == downgrade_uid:
     
109.                 print(f"{employee.name}，工号：{employee.uid}，当前职位：{employee.job}{employee.grade}，当前薪资：{employee.salarys}")
     
110.                 salary = employee.salarys
     
111.                 var_grade = int(input("请输入需要减少的级数："))
     
112.                 employee.grade -= var_grade
     
113.                 if employee.grade < 0:
     
114.                     if employee.job == 'M':
     
115.                         employee.job = 'T'
     
116.                     elif employee.job == 'T':
     
117.                         employee.job = 'E'
     
118.                     employee.grade = self.grade_dict[employee.job]
     
119.                 print("降级成功！")
     
120.                 employee.salarys = employee.salary()
     
121.                 print(f"{employee.name}，工号：{employee.uid}，降级后职位：{employee.job}{employee.grade}，降级后薪资：{employee.salarys}（{employee.salarys - salary:+}）")
     
122.                 break
     
123.         else:
     
124.             print("该工号不存在！")
     
125. 
     
126. def main():
     
127.     emp_manage = EmployeeManageSystem()
     
128.     while True:
     
129.         menu = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
     
130.         if not menu:
     
131.             continue
     
132.         if menu == '5':
     
133.             break
     
134. 
     
135.         elif menu == '1':
     
136.             emp_manage.add_employee()
     
137. 
     
138.         elif menu =='2':
     
139.             emp_manage.inquire_employee()
     
140. 
     
141.         elif menu == '3':
     
142.             emp_manage.upgrades()
     
143. 
     
144.         elif menu =='4':
     
145.             emp_manage.downgrades()
     
146. 
     
147. main()

复制代码

zhuanghli

请回复您的答案^_^

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

第 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 Attribution:
    def __init__(self, uid, name, job, grade, year, salary):
        self.get_uid = uid
        self.get_name = name
        self.get_job = job
        self.get_grade = grade
        self.get_year = year
        self.salary = salary

class Manage:
    def __init__(self):
        self.employee = {}
        self.teamleader = {}
        self.manager = {}
        self.uid = 10000


    def salary(self, 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)

    def ingrade(self, job):
        grade = int(input("级别："))
        if job == 'E':
            while grade < 1 or grade > 10:
                grade = int(input("该职位最高级别为10，请重新录入级别："))
        elif job == 'T':
            while not grade >= 1 or not grade <= 6:
                grade = int(input("该职位最高级别为6，请重新录入级别："))
        elif job == 'M':
            while not grade >= 1 or not grade <= 3:
                grade = int(input("该职位最高级别为6，请重新录入级别："))
        return grade

    def worker(self):
        uid = self.uid
        name = input("姓名：")
        job = input("职位（E.普通员工；T.组长；M.经理）：")
        year = int(input("工龄："))
        grade = self.ingrade(job)
        salary = self.salary(job, grade, year)
        if job == 'E':
            self.employee[uid] = Attribution(uid, name, job, grade, year, salary)
            print(f"录入成功！姓名：{self.employee[uid].get_name}, 工号：{self.employee[uid].get_uid}， 薪资：{self.employee[uid].salary}")
        elif job == 'T':
            self.teamleader[uid] = Attribution(uid, name, job, grade, year, salary)
            print(f"录入成功！姓名：{self.teamleader[uid].get_name}, 工号：{self.teamleader[uid].get_uid}， 薪资：{self.teamleader[uid].salary}")
        elif job == 'M':
            self.manager[uid] = Attribution(uid, name, job, grade, year, salary)
            print(f"录入成功！姓名：{self.manager[uid].get_name}, 工号：{self.manager[uid].get_uid}， 薪资：{self.manager[uid].salary}")
        self.uid += 1

    def namefind(self):
        uid = int(input("请输入工号："))
        if uid in self.employee:
            print(f"姓名:{self.employee[uid].get_name}\n职位：{self.employee[uid].get_job}\n级别：{self.employee[uid].get_grade}\n工龄：{self.employee[uid].get_year}\n薪资：{self.employee[uid].salary}")
        elif uid in self.teamleader:
            print(f"姓名:{self.teamleader[uid].get_name}\n职位：{self.teamleader[uid].get_job}\n级别：{self.teamleader[uid].get_grade}\n工龄：{self.teamleader[uid].get_year}\n薪资：{self.teamleader[uid].salary}")
        elif uid in self.manager:
            print(f"姓名:{self.manager[uid].get_name}\n职位：{self.manager[uid].get_job}\n级别：{self.manager[uid].get_grade}\n工龄：{self.manager[uid].get_year}\n薪资：{self.manager[uid].salary}")
        else:
            print("该工号不存在！")

    def jobfind(self):
        job = input("职位（E.普通员工；T.组长；M.经理）：")
        if job == 'E':
            if len(self.employee) == 0:
                print("目前公司没有普通员工！")
            else:
                print(f"目前普通员工共有{len(self.employee)}人：")
                for i in self.employee:
                    print(self.employee[i].get_uid, '-', self.employee[i].get_name)
        elif job == 'T':
            if len(self.teamleader) == 0:
                print("目前公司没有组长！")
            else:
                print(f"目前组长共有{len(self.teamleader)}人：")
                for i in self.teamleader:
                    print(self.employee[i].get_uid, '-', self.employee[i].get_name)
        elif job == 'M':
            if len(self.manager) == 0:
                print("目前公司没有经理！")
            else:
                print(f"目前经理共有{len(self.manager)}人：")
                for i in self.manager:
                    print(self.employee[i].get_uid, '-', self.employee[i].get_name)

    def upgrade(self):
        uid = int(input("请输入工号："))
        if uid in self.employee:
            print(f"{self.employee[uid].get_name}，工号：{self.employee[uid].get_uid}，当前职位：E{self.employee[uid].get_grade}，当前薪资：{self.employee[uid].salary}")
            old_salary = self.employee[uid].salary
            result = self.grade_change(self.employee[uid].get_grade, self.employee[uid].get_job)
            self.employee[uid].get_grade = result[0]
            self.employee[uid].salary = self.salary(result[1], result[0], self.employee[uid].get_year)
            change = self.employee[uid].salary - old_salary
            if change > 0:
                tick = '+'
            else:
                tick = ''
            print("升级成功！")
            if result[1] == 'E':
                print(f"{self.employee[uid].get_name}，工号：{self.employee[uid].get_uid}，当前职位：E{self.employee[uid].get_grade}，升级后薪资：{self.employee[uid].salary}({tick}{change})")
            elif result[1] == 'T':
                self.employee[uid].get_job = result[1]
                print(f"{self.employee[uid].get_name}，工号：{self.employee[uid].get_uid}，当前职位：T{self.employee[uid].get_grade}，升级后薪资：{self.employee[uid].salary}({tick}{change})")
                self.teamleader[uid] = self.employee[uid]
                self.employee.pop(uid)
            elif result[1] == 'M':
                self.employee[uid].get_job = result[1]
                print(f"{self.employee[uid].get_name}，工号：{self.employee[uid].get_uid}，当前职位：M{self.employee[uid].get_grade}，升级后薪资：{self.employee[uid].salary}({tick}{change})")
                self.manager[uid] = self.employee[uid]
                self.employee.pop(uid)
               
        elif uid in self.teamleader:
            print(f"{self.teamleader[uid].get_name}，工号：{self.teamleader[uid].get_uid}，当前职位：T{self.teamleader[uid].get_grade}，当前薪资：{self.teamleader[uid].salary}")
            old_salary = self.teamleader[uid].salary
            result = self.grade_change(self.teamleader[uid].get_grade, self.teamleader[uid].get_job)
            self.teamleader[uid].get_grade = result[0]
            self.teamleader[uid].salary = self.salary(result[1], result[0], self.teamleader[uid].get_year)
            change = self.teamleader[uid].salary - old_salary
            if change > 0:
                tick = '+'
            else:
                tick = ''
            print("升级成功！")
            if result[1] == 'T':
                print(f"{self.teamleader[uid].get_name}，工号：{self.teamleader[uid].get_uid}，当前职位：T{self.teamleader[uid].get_grade}，升级后薪资：{self.teamleader[uid].salary}({tick}{change})")
            elif result[1] == 'M':
                self.teamleader[uid].get_job = result[1]
                print(f"{self.teamleader[uid].get_name}，工号：{self.teamleader[uid].get_uid}，当前职位：M{self.teamleader[uid].get_grade}，升级后薪资：{self.teamleader[uid].salary}({tick}{change})")
                self.manager[uid] = self.teamleader[uid]
                self.teamleader.pop(uid)
               
        elif uid in self.manager:
            print(f"{self.manager[uid].get_name}，工号：{self.manager[uid].get_uid}，当前职位：M{self.manager[uid].get_grade}，当前薪资：{self.manager[uid].salary}")
            old_salary = self.manager[uid].salary
            result = self.grade_change(self.manager[uid].get_grade, self.manager[uid].get_job)
            self.manager[uid].get_grade = result[0]
            self.manager[uid].salary = self.salary(result[1], result[0], self.teamleader[uid].get_year)
            change = self.manager[uid].salary - old_salary
            if change > 0:
                tick = '+'
            else:
                tick = ''
            print("升级成功！")
            print(f"{self.manager[uid].get_name}，工号：{self.manager[uid].get_uid}，当前职位：M{self.manager[uid].get_grade}，升级后薪资：{self.manager[uid].salary}({tick}{change})")         
        else:
            print("该工号不存在！")

    def grade_change(self, grade, job):
        result = []
        add = int(input("请输入需要增加的级数："))
        num = grade + add
        if job == 'E':
            if num <= 10:
                result.append(num)
                result.append('E')
            elif 10 < num <= 16:
                result.append(num - 10)
                result.append('T')
            elif 16 < num <= 19:
                result.append(num - 16)
                result.append('M')
            else:
                print("超过最高级别，无效！")
                return [grade, job]
        elif job == 'T':
            if num <= 6:
                result.append(num)
                result.append('T')
            elif 6 < num <= 9:
                result.append(num - 6)
                result.append('M')
            else:
                print("超过最高级别，无效！")
                return [grade, job]
        elif job == 'M':
            if num <= 3:
                result.append(num)
                result.append('M')
            else:
                print("超过最高级别，无效！")
                return [grade, job]
        return result



def main():
    a = Manage()
    num = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
    while num != 5:
        if num == 1:
            a.worker()
        elif num == 2:
            choice = int(input("1.员工查询；2.职位查询："))
            if choice == 1:
                a.namefind()
            elif choice == 2:
                a.jobfind()
        elif num == 3:
            a.upgrade()
        elif num == 4:
            pass
        else:
            print("指令错误，请重新输入：")
        num = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
            
   
main()

nicezzz

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

ilaf

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

检测点11.1

one functin/method/attribute/operator can deal with different situation.

increase cohesion, decrease coupling.

yes, it's polymorphism.

when a thin looks like duck, bark like a duck, and walk like a duck, then it is a duck.

decrease coupling, because it deal with defferent object with uniform style.

yes, it s.

yes, it is.

保尔·柯察恒

请回复您的答案^_^

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

第 0 题的答案是：
同一个方法、运算符等因为被操作的对象不同而采取不同的处理方法、得到不一样的结果，叫做多态
第 1 题的答案是：
s使得代码更灵活
第 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 get_year(self):
        return self.year

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


class Teamleader(Employee):
    def __init__(self, empl):
        super().__init__(empl.uid, empl.name, 'T', empl.grade, empl.year)

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


class Manager(Employee):

    def __init__(self, empl):
        super().__init__(empl.uid, empl.name, 'M', empl.grade, empl.year)

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


class Main:

    def __init__(self):
        self.employees = []
        self.uid = 10000
        self.max_grage = {'E': 10, 'T': 6, 'M': 3}
        self.job_name = {'E': '普通员工', 'T': '组长', 'M': '经理'}

    def get_empl(self, uid):
        for e in self.employees:
            if uid == e.uid:
                return e
        else:
            return None

    def add(self):
        uid = self.uid
        name = input("姓名：")
        job = input("职位（E.普通员工；T.组长；M.经理）：")
        year = int(input("工龄："))
        grade = int(input("级别："))
        while grade > self.max_grage[job]:
            grade = int(input(f"该级别最高为{self.max_grage[job]}，请重新输入："))

        empl = Employee(uid, name, job, grade, year)
        if job == 'T':
            empl = Teamleader(empl)
        elif job == 'M':
            empl = Manager(empl)

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

    def empl_query(self):
        empl = self.get_empl(int(input("请输入工号：")))
        if not empl:
            print("该工号不存在 ")
            return
        print(f"姓名：{empl.name}")
        print(f"职位：{empl.job}")
        print(f"级别：{empl.grade}")
        print(f"工龄：{empl.year}")
        print(f"薪资：{empl.salary()}")

    def job_query(self):
        jobs = []
        cnt = 0
        job = input("职位（E.普通员工；T.组长；M.经理）：")
        for e in self.employees:
            if job == e.job:
                jobs.append(e)
                cnt += 1
        if cnt == 0:
            print(f"目前公司没有{self.job_name[job]}")
        else:
            print(f"目前{self.job_name[job]}共有{cnt}人")
            for e in jobs:
                print(f"{e.uid} - {e.name}")

    def query(self):
        op = input("1.员工查询；2.职位查询")
        if op == '1':
            self.empl_query()
        elif op == '2':
            self.job_query()

    def upgrade(self):
        empl = self.get_empl(int(input("请输入工号：")))
        if not empl:
            print("该工号不存在 ")
            return
        print(f"{empl.name}，工号：{empl.uid}，当前职位：{empl.job + str(empl.grade)}，当前薪资：{empl.salary()}")
        num = int(input("请输入需要增加的级数："))
        empl.grade += num
        if empl.grade > self.max_grage[empl.job]:
            self.employees.remove(empl)
            if empl.job == 'E':
                empl.grade = 1
                empl = Teamleader(empl)
            elif empl.job == 'T':
                empl.grade = 1
                empl = Manager(empl)
            elif empl.job == 'M':
                empl.grade = 3
                print("已经是最高级！")
            self.employees.append(empl)
        print(f"{empl.name}，工号：{empl.uid}，升级后职位：{empl.job + str(empl.grade)}，升级后薪资：{empl.salary()}")

    def downgrade(self):
        empl = self.get_empl(int(input("请输入工号：")))
        if not empl:
            print("该工号不存在 ")
            return
        print(f"{empl.name}，工号：{empl.uid}，当前职位：{empl.job + str(empl.grade)}，当前薪资：{empl.salary()}")
        num = int(input("请输入需要降低的级数："))
        empl.grade -= num
        if empl.grade < 1:
            self.employees.remove(empl)
            if empl.job == 'E':
                empl.grade = 1
                print("已经是最低级！")
            elif empl.job == 'T':
                empl = Employee(empl.uid, empl.name, 'E', 10, empl.year)
            elif empl.job == 'M':
                empl.grade = 6
                empl = Teamleader(empl)
            self.employees.append(empl)
        print(f"{empl.name}，工号：{empl.uid}，升级后职位：{empl.job + str(empl.grade)}，升级后薪资：{empl.salary()}")

    def welcome(self):
        while True:
            op = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
            if op == '1':
                self.add()
            elif op == '2':
                self.query()
            elif op == '3':
                self.upgrade()
            elif op == '4':
                self.downgrade()
            elif op == '5':
                break


def main():
    Main().welcome()


main()

zyx2012

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

liuhd666

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

彭彭不吃虫子

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

ahluo

请回复您的答案^_^

-------- 问答题 --------
第 0 题的答案是：不同输入会有不同的调用

第 1 题的答案是：一个函数可以在不同语境中实现不同功能

第 2 题的答案是：可以

第 3 题的答案是：不知道

第 4 题的答案是：高内聚

第 5 题的答案是：不是

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

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

ahnseil

不懂

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

请回复您的答案^_^

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

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

第 1 题的答案是：

第 2 题的答案是：可以

第 3 题的答案是：

第 4 题的答案是：增强了内聚

第 5 题的答案是：不是

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

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

def count_wages(job,grade,year):
    if job == 'E':
        money = 3000 + 500 * grade + 50 * year
        return money
    elif job == 'T':
        money = 4000 + 800 * grade + 100 * year
        return money
    elif job == 'M':
        money = 5000 + 1000 * (grade + year)
        return money
    else:
        print('没有这种职位')
        pass

def up_grade(up,graded,job0):
    if job0 == 'E' and graded <= 10:
        graded += up
        if 10 < graded <= 16:
            job0 = 'T'
            graded = graded - 10
        elif 16 < graded <= 19:
            job0 = 'M'
            graded = graded - 16
        else:
            print('升级错误')
    elif job0 == 'T' and graded <= 6:
        graded += up
        if 6 < graded <= 9:
            job0 = 'M'
            graded = graded - 6
        else:
            print('升级错误')
    else:
        print('输入有误')
    return graded,job0

def down_grade(down,graded,job0):
    if job0 == 'E':
        if graded - down > 0:
            graded = graded - down
        else:
            print('输入有误')
    elif job0 == 'T':
        if graded - down > 0:
            graded = graded - down
        elif -9 <= graded - down <= 0:
            job0 = 'E'
            graded = graded - down + 10
        else:
            print('输入有误')
    elif job0 == 'M':
        if graded - down > 0:
            graded = graded - down
        elif -5 <= graded - down <= 0:
            job0 = 'T'
            graded = graded - down + 6
        elif -15 <= graded - down < -5:
            job0 = 'E'
            graded = graded - down + 16
    else:
        print('输入有误')
    return graded,job0

all_uid = []

class MainManage:
    def __init__(self):
        self.members = {}
        self.uid = 10000
    def loading(self):
        name = input('姓名:')
        job = input('职位(E.普通员工;T.组长;M.经理):')
        year = int(input('工龄:'))
        grade = int(input('级别:'))
        money = count_wages(job,grade,year)
        member = Data(name,job,grade,year,self.uid,money)
        all_uid.append(self.uid)
        self.members[self.uid] = member
        print(f'录入成功!姓名: {name},工号: {10000},薪资: {money}')
        self.uid += 1
        print(dict(self.members))
    def query(self):
        query_what = input('1.员工查询;2.职位查询:')
        if query_what == '1':
            uid_input = int(input('请输入工号:'))
            while not self.members.get(uid_input):
                uid_input = int(input('该工号不存在'))
            print(f'姓名:{self.members[uid_input].name}\n职位:{self.members[uid_input].job}\n级别:{self.members[uid_input].grade}\n工龄:{self.members[uid_input].year}')
        elif query_what == '2':
            query_job = input('职位(E.普通员工;T.组长;M.经理):')
            n = 0
            member_list = []
            uid_list = []
            for i in all_uid:
                if self.members[i].job == query_job:
                    n += 1
                    uid_list.append(i)
                    member_list.append(self.members[i].name)
                else:
                    continue
            for i,j in member_list,uid_list:
                print(j,' - ',i)
    def upgrade(self):
        get_uid = int(input('请输入工号:'))
        print(f'{self.members[get_uid].name},工号:{self.members[get_uid].uid},当前职位:{self.members[get_uid].job}{self.members[get_uid].grade},当前薪资:{self.members[get_uid].money}')
        up = int(input('请输入需要增加的等级:'))
        print('升级成功')
        graded,job0= up_grade(up, self.members[get_uid].grade, self.members[get_uid].job)
        self.members[get_uid].grade = graded
        self.members[get_uid].job = job0
        money1 = count_wages(self.members[get_uid].job,self.members[get_uid].grade,self.members[get_uid].year)
        print(f'{self.members[get_uid].name}, 工号: {self.members[get_uid].uid}, 升级后职位:{self.members[get_uid].job}{self.members[get_uid].grade} 升级后薪资: {money1(money1-self.members[get_uid].money)}')
        self.members[get_uid].money = money1
    def downgrade(self):
        get_uid = int(input('请输入工号:'))
        print(f'{self.members[get_uid].name},工号:{self.members[get_uid].uid},当前职位:{self.members[get_uid].job}{self.members[get_uid].grade},当前薪资:{self.members[get_uid].money}')
        down = int(input('请输入需要减少的等级:'))
        graded,job0 = down_grade(down,self.members[get_uid].grade,self.members[get_uid].job)
        self.members[get_uid].grade = graded
        self.members[get_uid].job = job0
        money1 = count_wages(self.members[get_uid].job, self.members[get_uid].grade, self.members[get_uid].year)
        print(f'{self.members[get_uid].name}, 工号: {self.members[get_uid].uid}, 升级后职位:{self.members[get_uid].job}{self.members[get_uid].grade} 升级后薪资: {money1(money1 - self.members[get_uid].money)}')
        self.members[get_uid].money = money1
    def main_enter(self):
        s = input('1.录入;2.查询;3.升级;4.降级;5.退出:')
        if s == '1':
            self.loading()
        elif s == '2':
            self.query()
        elif s == '3':
            self.upgrade()
        elif s == '4':
            self.downgrade()
        elif s == '5':
            return 0
m = 1
while m:
    c = MainManage()
    c.main_enter()

sluttypumkin

请回复您的答案^_^

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

第 0 题的答案是：同一函数，对象在不同的场景下具有不同的效果体现

第 1 题的答案是：接收不同的对象作为参数，且不用检测参数类型可执行相应的方法

第 2 题的答案是：
可以

第 3 题的答案是：
当我们看见一只鸟的行为与鸭子行为相似的时候，我们就可以称它为鸭子

第 4 题的答案是：
高内聚低耦合

第 5 题的答案是：
不属于

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

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

###企业员工管理系统


##员工属性
class EmployeeInfo:
    def __init__(self,name,job,grade,year,uid):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
        self.uid = uid
   


###员工分类:普通员工
class Employee():
    def __init__(self,grade,year,job):
        self.grade = grade
        self.year = year
        self.job = job
        
    def salarys(self):
        print(f"grade:{self.grade},year:{self.year},job:{self.job}")
        
        return 3000 + 500 * self.grade + 50 * self.year


class Teamleader():
    def __init__(self,grade,year,job):
        self.grade = grade
        self.year = year
        self.job = job
        
    def salarys(self):
        print(f"grade:{self.grade},year:{self.year},job:{self.job}")

        return 4000 + 800 * self.grade + 100 * self.year


class Manager():
    def __init__(self,grade,year,job):
        self.grade = grade
        self.year = year
        self.job = job
        
    def salarys(self):
        print(f"grade:{self.grade},year:{self.year},job:{self.job}")

        return 5000 + 1000 * (self.grade + self.year)


class Manage:
    def __init__(self):
        self.uid = 10000
        self.employees = {}

    def get_uid(self):
        return self.uid

    def get_name(self):
        self.name = input("姓名：")
        return self.name

    def get_job(self):
         self.job = input("职位（E.普通员工;T.组长;M.经理）：")
         return self.job
    def get_grade(self):
         self.grade = int(input("级别："))
         return self.grade
    def get_year(self):
        self.year = int(input("工龄："))
        return self.year

    def check_grade(self,job,grade):
        if self.job == 'E':
            if self.grade > 10:
                self.grade = int(input("该职务最高级别为10，请重新录入:"))
            return self.grade
        elif self.job == 'T':
            if self.grade > 6:
                self.grade = int(input("该职务最高级别为6，请重新录入:"))
            return self.grade
        elif self.job == 'M':
            if self.grade > 3:
                self.grade = int(input("该职务最高级别为3，请重新录入:"))
            return self.grade
        
    def confirm_uid(self):
        uid = int(input("请输入工号："))
        if not self.employees.get(uid):
            print("该工号不存在！")
        
        return uid
        
    def welcome(self):
        ybz = ''
        while ybz != '5':
            ybz = input("1.录入;2.查询;3.升级;4.降级;5.退出：")
            if ybz == '1':
                self.create_info()
            elif ybz == '2':
                self.search()
            elif ybz == '3':
                self.levelup()
            elif ybz == '4':
                self.leveldown()
            elif ybz == '5':
                pass
            
    def salary(self,x):
        return x.salarys()
            
    def create_info(self):
        name = self.get_name()
        uid = self.get_uid()
        job = self.get_job()
        grade = self.get_grade()
        grade = self.check_grade(job,grade)
        year = self.get_year()
        employee = EmployeeInfo(name,job,grade,year,uid)
        
        if job == 'E':
            e = Employee(grade,year,job)
        elif job == 'T':
            e = Teamleader(grade,year,job)
        elif job == 'M':
            e = Manager(grade,year,job)
            
        salary = self.salary(e)
        
        self.employees[uid] = employee
        print(f"录入成功！姓名：{name},工号：{uid}，薪资:{salary}")
        self.uid += 1

    def search(self):
        ys = ''
        while ys != '3':
            ys = input("1.员工查询;2.职位查询;3.退出查询：")
            if ys == '1':
                uid = self.confirm_uid()
                if self.employees.get(uid):
                    if self.employees.get(uid).uid == uid:
                        print(f"姓名:{self.employees.get(uid).name} ")
                        print(f"职位:{self.employees.get(uid).job} ")
                        print(f"级别:{self.employees.get(uid).grade} ")
                        print(f"工龄:{self.employees.get(uid).year} ")
                        if self.employees.get(uid).job == 'E':
                            e = Employee(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
                        elif self.employees.get(uid).job == 'T':
                            e = Teamleader(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
                        elif self.employees.get(uid).job == 'M':
                            e = Manager(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
                        print(f"薪资:{self.salary(e)}")
                        
            elif ys == '2':
                count = 0
                user = {}
                job = self.get_job()
                for i in set(self.employees):
                    if self.employees[i].job == job:
                        count += 1
                        user[i] = self.employees[i].name
                if job == 'E':
                    print(f"目前普通员工共有{count}人")
                elif job == 'T':
                    print(f"目前组长共有{count}人")
                elif job == 'M':
                    print(f"目前经理共有{count}人")
                for keys,values in user.items():
                    print(f"{keys} - {values}")
                    
    def levelup(self):
        uid = self.confirm_uid()
        levelsalary = 0
        levelupsalary = 0
        if self.employees.get(uid):
            if self.employees.get(uid).uid == uid:
                if self.employees.get(uid).job == 'E':
                    e = Employee(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
                elif self.employees.get(uid).job == 'T':
                    e = Teamleader(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
                elif self.employees.get(uid).job == 'M':
                    e = Manager(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
                levelsalary = self.salary(e)
               
                print(f"{self.employees.get(uid).name},",end="")
                print(f"工号:{uid}，当前职位：{self.employees.get(uid).job}{self.employees.get(uid).grade} ",end="")
                print(f"当前薪资:{levelsalary}")
               
        level = int(input("请输入需要增加的级数："))
        
        if self.employees.get(uid).job == 'E':
            while level + self.employees.get(uid).grade - 16 > 3:
                level = int(input("增加级数超过最高等级，请重新录入:"))
            if level + self.employees.get(uid).grade > 10:
                if level + self.employees.get(uid).grade - 10 > 6:
                    self.employees.get(uid).job = 'M'
                    self.employees.get(uid).grade += (level-10-6)
                else:
                    self.employees.get(uid).job = 'T'
                    self.employees.get(uid).grade += (level-10)
            else:
                self.employees.get(uid).grade += level
                    
                        
        elif self.employees.get(uid).job == 'T':
            while level + self.employees.get(uid).grade - 6 > 3:
                level = int(input("增加级数超过最高等级，请重新录入:"))
               
            if level + self.employees.get(uid).grade > 6:
                self.employees.get(uid).job = 'M'
                self.employees.get(uid).grade += (level-6)
            else:
                self.employees.get(uid).grade += level
                    
        elif self.employees.get(uid).job == 'M':
            while level + self.employees.get(uid).grade > 3:
                level = int(input("增加级数超过最高等级，请重新录入:"))
            self.employees.get(uid).grade += level

        if self.employees.get(uid).job == 'E':
            t = Employee(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
        elif self.employees.get(uid).job == 'T':
            t = Teamleader(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
        elif self.employees.get(uid).job == 'M':
            t = Manager(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
            
        levelupsalary = self.salary(t)
        
        print(f"levelupsalary:{levelupsalary}")
        print("升级成功")
        print(f"{self.employees.get(uid).name},",end="")
        print(f"工号:{uid}，升级后职位：{self.employees.get(uid).job}{self.employees.get(uid).grade} ",end="")
        print(f"升级后薪资:{levelupsalary}(+{levelupsalary-levelsalary})")

    def leveldown(self):
        uid = self.confirm_uid()
        levelsalary = 0
        levelupsalary = 0
        if self.employees.get(uid):
            if self.employees.get(uid).uid == uid:
                if self.employees.get(uid).job == 'E':
                    e = Employee(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
                elif self.employees.get(uid).job == 'T':
                    e = Teamleader(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
                elif self.employees.get(uid).job == 'M':
                    e = Manager(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
                levelsalary = self.salary(e)
                print(f"{self.employees.get(uid).name},",end="")
                print(f"工号:{uid}，当前职位：{self.employees.get(uid).job}{self.employees.get(uid).grade} ",end="")
                print(f"当前薪资:{levelsalary}")
        level = int(input("请输入需要降级的级数："))
        
        if self.employees.get(uid).job == 'M':
            while self.employees.get(uid).grade < level - 16:
                level = int(input("降级级数小于最低等级，请重新录入:"))
            if self.employees.get(uid).grade  <= level :
                if level - self.employees.get(uid).grade <  6:
                    self.employees.get(uid).job = 'T'
                    self.employees.get(uid).grade += (6 - level)
                else:
                    self.employees.get(uid).job = 'E'
                    self.employees.get(uid).grade += (16 - level)
            else:
                self.employees.get(uid).grade -= level
                    
                        
        elif self.employees.get(uid).job == 'T':
            while self.employees.get(uid).grade  < level - 10:
                level = int(input("降级级数小于最低等级，请重新录入:"))
               
            if self.employees.get(uid).grade <= level :
                self.employees.get(uid).job = 'E'
                self.employees.get(uid).grade += (10-level)
            else:
                self.employees.get(uid).grade -= level
                    
        elif self.employees.get(uid).job == 'E':
            while self.employees.get(uid).grade < level :
                level = int(input("降级级数小于最低等级，请重新录入:"))
            self.employees.get(uid).grade -= level
        if self.employees.get(uid).job == 'E':
            t = Employee(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
        elif self.employees.get(uid).job == 'T':
            t = Teamleader(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
        elif self.employees.get(uid).job == 'M':
            t = Manager(self.employees.get(uid).grade,self.employees.get(uid).year,self.employees.get(uid).job)
            
        levelupsalary = self.salary(t)
        print(f"levelupsalary:{levelupsalary}")
        print("降级成功")
        print(f"{self.employees.get(uid).name},",end="")
        print(f"工号:{uid}，降级后职位：{self.employees.get(uid).job}{self.employees.get(uid).grade} ",end="")
        print(f"降级后薪资:{levelupsalary}({levelupsalary-levelsalary})")        
        
def main():
    manage = Manage()
    manage.welcome()
        

python王..

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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