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

yangmiao07

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

1

语冰

1

nmdorceo

0.不同场景下采取不同的作用
1.方便理解和运算，一切都是那么的理所应当
2.可以称为多态
3.龙生龙，凤生凤，老鼠生的会打洞
4.降低了耦合度
5.不属于
动动手：
0.
class Attribute:
    def __init__(self, name, job, grade, year, salary):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
        self.salary = salary

class gradecheckMixin:
    def gradecheck(self, job, grade):
        if job == "E" and int(grade) > 10:
            self.grade = input("该职位最高级别为10，请重新录入级别：")
            gradecheckMixin.gradecheck(self, job, self.grade)
        elif job == "T" and int(grade) > 6:
            self.grade = input("该职位最高级别为6，请重新录入级别：")
            gradecheckMixin.gradecheck(self, job, self.grade)
        elif job == "M" and int(grade) > 3:
            self.grade = input("该职位最高级别为3，请重新录入级别：")
            gradecheckMixin.gradecheck(self, job, self.grade)
        else:
            return self.grade
        
        

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

class RegradeMixin:
    def up_job_grade(self, job, grade):
        self.level = int(input("请输入需要增加的级数："))
        #self.totallevel = 0
        
        if job == "E":
            self.totallevel = int(grade) + self.level
        elif job == "T":
            self.totallevel = int(grade) + self.level + 10
        elif job == "M":
            self.totallevel = int(grade) + self.level + 16
            #print(self.totallevel, "--1")
        while self.totallevel > 19:
            self.level = int(input("增加级数超出范围,请重新输入需要增加的级数："))
            if job == "E":
                self.totallevel = int(grade) + self.level
            elif job == "T":
                self.totallevel = int(grade) + self.level + 10
            elif job == "M":
                self.totallevel = int(grade) + self.level + 16
        else:
            
            if job == "E" and self.totallevel <= 10:
                self.grade = self.totallevel
            elif job == "E" and 10 < self.totallevel <= 16:
                self.job = "T"
                self.grade = 1
            elif job == "E" and 16 < self.totallevel <= 19:
                self.job = "M"
                self.grade = 1
            elif job == "T" and 10 < self.totallevel <= 16:
                self.grade = self.totallevel - 10
            elif job == "T" and 16 < self.totallevel <= 19:
                self.job = "M"
                self.grade = 1
            elif job == "M" and 16 < self.totallevel <= 19:
                self.grade = self.totallevel - 10 - 6
        return self.job, self.grade
   
    def down_job_grade(self, job, grade):
        
        self.level =  -int(input("请输入需要减少的级数："))
        if job == "E":
            self.totallevel = int(grade) + self.level
        elif job == "T":
            self.totallevel = int(grade) + self.level + 10
        elif job == "M":
            self.totallevel = int(grade) + self.level + 16
        while self.totallevel < 1:
            self.level =  -int(input("增加级数超出范围,请重新输入需要减少的级数："))
            if job == "E":
                self.totallevel = int(grade) + self.level
            elif job == "T":
                self.totallevel = int(grade) + self.level + 10
            elif job == "M":
                self.totallevel = int(grade) + self.level + 16
        else:
            if job == "E" and self.totallevel <= 10:
                self.grade = self.totallevel
            elif job == "T" and 10 < self.totallevel <= 16:
                self.grade = self.totallevel - 10
            elif job == "T" and self.totallevel <= 10:
                self.job = "E"
                self.grade = 10
            elif job == "M" and self.totallevel <= 10:
                self.job = "E"
                self.grade = 10
            elif job == "M" and 10 < self.totallevel <= 16:
                self.job = "T"
                self.grade = 6
            elif job == "M" and 16 < self.totallevel <= 19:
                self.grade = self.totallevel - 10 - 6
        return self.job, self.grade

class Manager(gradecheckMixin, salaryMixin, RegradeMixin):
    Managerdict = {"E":{}, "T":{}, "M":{}}
    uid = 10000
    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_year(self):
        self.year = input("工龄：")
        return self.year
   
    def get_grade(self):
        self.grade = input("级别：")
        super().gradecheck(self.job, self.grade)
        return self.grade
   
    def get_salary(self):
        super().salarycompute(self.job, self.grade, self.year)
        return self.salary
   
    def record(self):
        self.Managerdict[self.job][self.uid] = Attribute(self.name, self.job, self.grade, self.year, self.salary)
        print(f"录入成功！姓名：{self.name}, 工号：{self.uid}, 薪资：{self.salary}", "\n")
        self.uid += 1

    def inquire_uid(self):
        self.__uid = int(input("请输入工号："))
        for i in self.Managerdict.values():            
            if i.get(self.__uid) == None:
                continue
            else:
                print("姓名：", i.get(self.__uid).name)
                print("职位：", i.get(self.__uid).job)
                print("级别：", i.get(self.__uid).grade)
                print("工龄：", i.get(self.__uid).year)
                print("薪资：", i.get(self.__uid).salary, "\n")
               
        if self.Managerdict["E"].get(self.__uid) == self.Managerdict["T"].get(self.__uid) == self.Managerdict["M"].get(self.__uid) == None:
            print("该工号不存在！", "\n")
            
    def inquire_job(self):
        self.__job = input("职位（E.普通员工；T.组长；M.经理）：")
        if len(self.Managerdict[self.__job]) != 0:
            print(f"目前普通员工共有{len(self.Managerdict[self.__job])}人：")
            for i in self.Managerdict[self.__job]:
                print(f"{i} - {self.Managerdict[self.__job][i].name}", "\n")
        else:
            self.__dict = {"E":"普通员工", "T":"组长", "M":"经理"}
            print(f"目前公司没有{self.__dict[self.__job]}!", "\n")
            
    def upgrade(self):
        self.__uid = int(input("请输入工号："))
        for i in self.Managerdict.values():
            if i.get(self.__uid):
                print(f"{i.get(self.__uid).name},工号:{self.__uid}, 当前职位：{i.get(self.__uid).job + str(i.get(self.__uid).grade)},当前薪资：{i.get(self.__uid).salary}")
                self.fron_salary = i.get(self.__uid).salary
                super().up_job_grade(i.get(self.__uid).job, i.get(self.__uid).grade)
                i[self.__uid].job = self.job
                i[self.__uid].grade = self.grade
                super().salarycompute(i.get(self.__uid).job, i.get(self.__uid).grade, i.get(self.__uid).year)
                i[self.__uid].salary = self.salary
                self.now_salary = i.get(self.__uid).salary
                self.__updatedict = i.pop(self.__uid)
                self.Managerdict[self.job][self.__uid] = Attribute(self.__updatedict.name, self.__updatedict.job, self.__updatedict.grade, self.__updatedict.year, self.__updatedict.salary)
                print("升级成功!")
                for j in self.Managerdict.values():     
                    if j.get(self.__uid):
                        print(f"{j.get(self.__uid).name},工号:{self.__uid}, 升级后职位：{j.get(self.__uid).job + str(j.get(self.__uid).grade)},升级后薪资：{j.get(self.__uid).salary}({(self.now_salary-self.fron_salary):+})", "\n")
                break

    def downgrade(self):
        self.__uid = int(input("请输入工号："))
        for i in self.Managerdict.values():
            if i.get(self.__uid) :
                print(f"{i.get(self.__uid).name},工号:{self.__uid}, 当前职位：{i.get(self.__uid).job + str(i.get(self.__uid).grade)},当前薪资：{i.get(self.__uid).salary}")
                self.fron_salary = i.get(self.__uid).salary
                super().down_job_grade(i.get(self.__uid).job, i.get(self.__uid).grade)
                i[self.__uid].job = self.job
                i[self.__uid].grade = self.grade
                super().salarycompute(i.get(self.__uid).job, i.get(self.__uid).grade, i.get(self.__uid).year)
                i[self.__uid].salary = self.salary
                self.now_salary = i.get(self.__uid).salary
                self.__updatedict = i.pop(self.__uid)
                self.Managerdict[self.job][self.__uid] = Attribute(self.__updatedict.name, self.__updatedict.job, self.__updatedict.grade, self.__updatedict.year, self.__updatedict.salary)
                print("降级成功!")
                for j in self.Managerdict.values():     
                    if j.get(self.__uid):
                        print(f"{j.get(self.__uid).name},工号:{self.__uid}, 降级后职位：{j.get(self.__uid).job + str(j.get(self.__uid).grade)},降级后薪资：{j.get(self.__uid).salary}({(self.now_salary-self.fron_salary):+})", "\n")
                break
                    

               
        

   
def main():
    m = Manager()
    while True:
        command = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
        if command == "1":
            m.get_name()
            m.get_job()
            m.get_year()
            m.get_grade()
            m.get_salary()
            m.record()
        elif command == "2":
            comand_ = input("1.员工查询;2.职位查询：")
            if comand_ == "1":
                m.inquire_uid()
            else:
                m.inquire_job()
        elif command == "3":
            m.upgrade()
        elif command == "4":
            m.downgrade()
        elif command == "5":
            break
        
main()

wtc

来了

CoupleHunnid

人间无事人

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.不算吧，只是做了默认参数的功能

么11

8

川响

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.

荧荧怪

0. 同一种函数，使用不同的类时，实现不同的功能
1. 封装，容易阅读，
2. 可以
3. 没有一只鸭子能活着走出南京
4. 降低耦合度
5. 不属于
0.

1. class Men:
   
2.     uid = 10000
   
3.     def __init__(self, name = None, job = None, grade = 0, year = 0):
   
4.         self.name = name
   
5.         self.job = job
   
6.         self.grade = grade
   
7.         self.year = year
   
8. 
   
9.     def get_name(self):
   
10.         self.name = input("姓名：")
    
11.         return self.name
    
12.         
    
13.     def get_job(self):
    
14.         self.job = input("职位（E.普通员工；T.组长；M.经理）：")
    
15.         return self.job
    
16.         
    
17.     def get_grade(self):
    
18.         self.grade = int(input("级别："))
    
19.         return self.grade
    
20.         
    
21.     def get_year(self):
    
22.         self.year = int(input("工龄："))
    
23.         return self.year
    
24.         
    
25.     def get_uid(self):
    
26.         return self.uid
    
27. 
    
28.     def p(self):
    
29.         print(self.gather[10000].__dict__)
    
30. #-----------------------------------------------------------------------------------------------        
    
31. class Employee(Men):
    
32.     gather = {}
    
33.     def salary(self, grade, year):
    
34.         return (3000 + 500 * grade + 50 * year)
    
35.    
    
36. class Teamleader(Men):
    
37.     gather = {}
    
38.     def salary(self, grade, year):
    
39.         return (4000 + 800 * grade + 100 * year)
    
40. 
    
41. class Manager(Men):
    
42.     gather = {}
    
43.     def salary(self, grade, year):
    
44.         return (5000 + 1000 * (grade + year))
    
45. #-----------------------------------------------------------------------------------------------   
    
46. def get_salary(job, grade, year):
    
47.     if job == "E":
    
48.         s = Employee()
    
49.         while grade > 10 or grade <= 0:
    
50.             grade = int(input("该职位最高级别为10，请重新输入:"))
    
51.     if job == "T":
    
52.         s = Teamleader()
    
53.         while grade > 6 or grade <= 0:
    
54.             grade = int(input("该职位最高级别为6，请重新输入:"))
    
55.     if job == "M":
    
56.         s = Manager()
    
57.         while grade > 3 or grade <= 0:
    
58.             grade = int(input("该职位最高级别为3，请重新输入:"))
    
59.     return (s.salary(grade, year), grade)
    
60. 
    
61. def get_group(job,men):
    
62.     if job == "E":
    
63.         s = Employee()
    
64.         s.gather[Men.uid] = men
    
65.     if job == "T":
    
66.         s = Teamleader()
    
67.         s.gather[Men.uid] = men
    
68.     if job == "M":
    
69.         s = Manager()
    
70.         s.gather[Men.uid] = men
    
71. #-----------------------------------------------------------------------------------------------
    
72. class Mange(Men):
    
73.     gather = {}
    
74.     def lu_ru(self):
    
75.         name = self.get_name()
    
76.         job = self.get_job()
    
77.         year = self.get_year()
    
78.         grade = self.get_grade()
    
79.         sal, grade = get_salary(job, grade, year)
    
80.         men = Men(name, job, grade, year)
    
81.         men.salary = sal
    
82.         self.gather[Men.uid] = men
    
83.         get_group(job,men)
    
84.         print(self.gather[Men.uid].__dict__)
    
85.         Men.uid += 1
    
86.         
    
87.     def cha_xu_01(self):
    
88.         gong_hao = int(input("请输入工号："))
    
89.         print(self.gather)
    
90.         if not self.gather.get(gong_hao):
    
91.             print("工号不存在！")
    
92.         else:
    
93.             print("姓名：", self.gather[gong_hao].name)
    
94.             print("职位：", self.gather[gong_hao].job)
    
95.             print("级别：", self.gather[gong_hao].grade)
    
96.             print("工龄：", self.gather[gong_hao].year)
    
97.             print("薪资：", self.gather[gong_hao].salary)
    
98.     def cha_xu_02(self):
    
99.         zhi_wei = input("职位（E.普通员工；T.组长；M.经理）:")
    
100.         if zhi_wei == "E":
     
101.             s = Employee()
     
102.             print(f"目前普通员工有{ len(s.gather)}人")
     
103.             for i in s.gather:
     
104.                 print("工号：", i, "姓名：", s.gather[i].name)
     
105.         elif zhi_wei == "T":
     
106.             s = Teamleader()
     
107.             print(f"目前组长有{ len(s.gather)}人")
     
108.         elif jzhi_weiob == "M":
     
109.             s = Manager()
     
110.             print(f"目前经理有{ len(s.gather)}人")  
     
111.         else:
     
112.             print("职位不存在！")
     
113.     def cha_xu(self):
     
114.         one_or_two = int(input("1.员工查询；2.职位查询："))
     
115.         if one_or_two == 1:
     
116.             self.cha_xu_01()
     
117.         elif one_or_two == 2:
     
118.             self.cha_xu_02()
     
119.             
     
120.     def sheng_zhi(self):
     
121.         num = int(input("请输入工号："))
     
122.         if self.gather.get(num):
     
123.             print(f"{self.gather[num].name}, 工号：{num}， 当前职位{self.gather[num].job}{self.gather[num].grade}, 当前薪资：{self.gather[num].salary}")
     
124.         else:
     
125.             print("工号不存在！")
     
126.         up_num = int(input("请输入需要增加的级数："))
     
127.         if self.gather[num].job == "E":
     
128.             base = self.gather[num].grade + up_num
     
129.             if base > 10:
     
130.                 self.gather[num].job = "T"
     
131.                 self.gather[num].grade = 1
     
132.                 sal, grade = get_salary(self.gather[num].job, self.gather[num].grade, self.gather[num].year)
     
133.                 self.gather[num].salary = sal
     
134.                 print("升职成功！")
     
135.                 print(f"{self.gather[num].name}, 工号：{num}， 升职后职位{self.gather[num].job}{self.gather[num].grade}, 升职后薪资：{self.gather[num].salary}")
     
136.                 return
     
137.             else:
     
138.                 self.gather[num].grade = base
     
139.                 sal, grade = get_salary(self.gather[num].job, self.gather[num].grade, self.gather[num].year)
     
140.                 self.gather[num].salary = sal
     
141.                 print("升职成功！")
     
142.                 print(f"{self.gather[num].name}, 工号：{num}， 升职后职位:{self.gather[num].job}{self.gather[num].grade}, 升职后薪资：{self.gather[num].salary}")
     
143.                 return
     
144.         if self.gather[num].job == "T":
     
145.             base = self.gather[num].grade + up_num
     
146.             if base > 6:
     
147.                 self.gather[num].job = "M"
     
148.                 self.gather[num].grade = 1
     
149.                 sal, grade = get_salary(self.gather[num].job, self.gather[num].grade, self.gather[num].year)
     
150.                 self.gather[num].salary = sal
     
151.                 print("升职成功！")
     
152.                 print(f"{self.gather[num].name},工号：{num}，升职后职位:{self.gather[num].job}{self.gather[num].grade}, 升职后薪资：{self.gather[num].salary}")
     
153.                 return
     
154.             else:
     
155.                 self.gather[num].grade = base
     
156.                 sal, grade = get_salary(self.gather[num].job, self.gather[num].grade, self.gather[num].year)
     
157.                 self.gather[num].salary = sal
     
158.                 print("升职成功！")
     
159.                 print(f"{self.gather[num].name}, 工号：{num}， 升职后职位:{self.gather[num].job}{self.gather[num].grade}, 升职后薪资：{self.gather[num].salary}")
     
160.                 return
     
161.         if self.gather[num].job == "M":
     
162.             base = self.gather[num].grade + up_num
     
163.             if base > 3:
     
164.                 self.gather[num].grade = 3
     
165.                 sal, grade = get_salary(self.gather[num].job, self.gather[num].grade, self.gather[num].year)
     
166.                 self.gather[num].salary = sal
     
167.                 print("升职成功！已是最高职位了")
     
168.                 print(f"{self.gather[num].name}, 工号：{num}， 升职后职位{self.gather[num].job}{self.gather[num].grade}, 升职后薪资：{self.gather[num].salary}")
     
169.                 return
     
170.             else:
     
171.                 self.gather[num].grade = base
     
172.                 sal, grade = get_salary(self.gather[num].job, self.gather[num].grade, self.gather[num].year)
     
173.                 self.gather[num].salary = sal
     
174.                 print("升职成功！")
     
175.                 print(f"{self.gather[num].name},工号：{num},升职后职位{self.gather[num].job}{self.gather[num].grade}, 升职后薪资：{self.gather[num].salary}")
     
176.                 return
     
177. #-----------------------------------------------------------------------------------------------
     
178. def main():
     
179.     m = Mange()
     
180.     while True:
     
181.         order = input("1.录入；2.查询；3.升职；4.降职；5.退出：")
     
182.         if order == '5':
     
183.             print("已退出。")
     
184.             break
     
185.         elif order == '1':
     
186.             m.lu_ru()
     
187.         elif order == '2':
     
188.             m.cha_xu()
     
189.         elif order == '3':
     
190.             m.sheng_zhi()
     
191. 
     
192. main()

复制代码

小小孛

0

lbh8399

0.一个方法可以用在不同类型的数据上
1.可以让方法使用更加简洁
2.可以的
3.
4.降低耦合
5.不是

阿伟同学

0.运算符，函数，对象在不同的情况下会发挥出不同的功能；
1.更加有逻辑性和更加具有条理性
2.可以
3.“当我看到一只走路像鸭子，游泳像鸭子，嘎嘎叫像鸭子的鸟时，我就称它为鸭子。”
4.降低耦合
5.不是

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

class Mixin:
    def  is_uid_exist(self):
        uid = int(input("请输入工号：").strip())
        if uid not in self.staffs:
            return None
        return uid
   
    def is_grade_match_job(self, job, grade):
        min_grade, max_grade = self.job_state[job][1], self.job_state[job][2]

        while grade > max_grade or grade < min_grade:
            grade = int(input(f"该职位的最该级别为{max_grade}，请重新录入级别：").strip())
        return grade

    def is_job_exist(self, job):
        while job not in [each for each in "ETM"]:
            job = input("请输入正确的职位缩写（E/T/M）：").strip()
        return job

    def jin_wei_qi(self, _min, _max, pre, c):
        if pre + c < _min:
            return -1
        elif pre + c > _max:
            return 1
        else:
            return 0

    def chage_grade(self, staff, job, grade, c):
        min_grade, max_grade = self.job_state[job][1], self.job_state[job][2]        
        r = self.jin_wei_qi(min_grade, max_grade, grade, c)
        l = list(self.jobs.keys())
        if r == -1:
            if job != l[0]:
                self.jobs[job].remove(staff)
                index = l.index(job) - 1
                self.jobs[l[index]].append(staff)
                return l[index] + str(self.job_state[l[index]][2])
            else:
                return l[0] + self.job_state[l[0]][1]
        elif r == 1:
            if job != l[-1]:
                self.jobs[job].remove(staff)
                index = l.index(job) + 1
                self.jobs[l[index]].append(staff)
                return l[index] + str(self.job_state[l[index]][1])
            else:
                return l[-1] + self.job_state[l[-1]][2]
        else:
            return job + str(grade + c)
   
class Manage(Mixin):
    staffs = {}
    uid = 10000
    jobs = dict(zip('ETM', [[], [], []]))
    job_state = dict([('E', ("普通员工", 1, 10)), ('T', ("组长", 1, 6)), ('M', ("经理", 1, 3))])

    def manage(self):
        while True:
            ins = input("\n1.录入；2.查询；3.升级；4.降级；5.退出：").strip()
            if ins == '5':
                break
            elif ins == '1':
                self.register()
            elif ins == '2':
                self.find()
            elif ins == '3':
                self.upgrade()
            elif ins == '4':
                self.degrade()
            else:
                print("请输入正确的指令")

    def register(self):
        name = input("姓名：").strip()
        job = input("职位（E.普通员工；T.组长；M.经理）：").strip()
        job = self.is_job_exist(job)
        year = int(input("工龄：").strip())
        grade = int(input("级别：").strip())
        grade = self.is_grade_match_job(job, grade)
        staff = Staff(name, job, grade, year, self.uid)
        self.staffs[self.uid] = staff
        self.jobs[job].append(staff)
        print(f"录入成功！姓名：{staff.name}，工号：{staff.uid}，薪资：{staff.salary()}")
        self.uid += 1

    def find(self):
        ins = input("1.员工查询；2.职位查询：").strip()
        if ins == '1':
            uid = self.is_uid_exist()
            if not uid:
                print("该工号不存在！")
            else:
                staff = self.staffs[uid]
                print(f"姓名：{staff.name}\n职位：{staff.job}\n级别：{staff.grade}\n工龄：{staff.year}\n薪资：{staff.salary()}")
        elif ins == '2':
            job = input("职位（E.普通员工；T.组长；M.经理)：").strip()
            job = self.is_job_exist(job)
            if not self.jobs[job]:
                print(f"目前公司没有{self.job_state[job][0]}！")
            else:
                print(f"目前{self.job_state[job][0]}共有 {len(self.jobs[job])} 人:")
                for each in self.jobs[job]:
                    print(f"{each.uid} - {each.name}")

    def upgrade(self):
        uid = self.is_uid_exist()
        if not uid:
            print("该工号不存在！")
        else:
            staff = self.staffs[uid]
            salary = staff.salary()
            job = staff.job
            print(f"{staff.name}, 工号：{staff.uid}, 当前职位：{staff.job + str(staff.grade)}，当前薪资：{staff.salary()}")
            n = int(input("请输入需要增加的级数：").strip())
            job = self.chage_grade(staff, job, staff.grade, n)
            staff.job = job[0]
            staff.grade = int(job[1:])
            print("升级成功！")
            print(f"{staff.name}, 工号：{staff.uid}, 升职后职位：{staff.job + str(staff.grade)}，当前薪资：{staff.salary()}({staff.salary() - salary:+})")

    def degrade(self):
        uid = self.is_uid_exist()
        if not uid:
            print("该工号不存在！")
        else:
            staff = self.staffs[uid]
            salary = staff.salary()
            job = staff.job
            print(f"{staff.name}, 工号：{staff.uid}, 当前职位：{staff.job + str(staff.grade)}，当前薪资：{staff.salary()}")
            n = int(input("请输入需要减少的级数：").strip())
            job = self.chage_grade(staff, job, staff.grade, -n)
            staff.job = job[0]
            staff.grade = int(job[1:])
            print("降级成功！")
            print(f"{staff.name}, 工号：{staff.uid}, 升职后职位：{staff.job + str(staff.grade)}，当前薪资：{staff.salary()}({staff.salary() - salary:+})")            

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

Spruance117

2. 可以
5. 不是
输入对象都是 int 类的变量 只是 z是否按默认取值

0.
def main():
    index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
    uid = 9999
    worker = [0 for i in range(uid+1)]
    while index!=5:
        if index == 1:
            name = input("姓名：")
            job = input("职位（E.普通员；T.组长；M.经理）：")
            if job == 'E':
                max_grade = 10
            elif job == 'T':
                max_grade = 6
            elif job == 'M':
                max_grade = 3
            year = int(input("工龄："))
            grade = int(input("级别："))
            while grade>max_grade:
                grade = int(input(f"该职位最高级别为{max_grade}，请重新录入级别："))

            
            uid += 1
            worker.append(0)
            worker[uid] = Worker(name,job,grade,year,uid)
            print(f"录入成功！姓名：{worker[uid].name},工号：{uid},资薪：{worker[uid].salary()}")
            index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))

        elif index == 2:
            check = int(input("1.员工查询；2.职位查询："))
            if check == 1:
                _ = int(input("请输入工号："))
                if _>len(worker)-1 or _<10000:
                    print("该员工不存在!")
                    index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
                else:
                    worker[_].worker_inquire()
                    index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
            elif check == 2:
                job_ = input("职位（E.普通员；T.组长；M.经理）：")
                sum1 = sum([1 for i in worker[10000:] if i.job == job_])
                if sum1 == 0:
                    if job_ == 'E':
                        print("目前公司没有普通员工")
                    elif job_ == 'T':
                        print("目前公司没有组长")
                    elif job_ == 'M':
                        print("目前公司没有经理")
                else:
                    if job_ == 'E':
                        print("目前普通员工共有{}人".format(sum1))
                    elif job_ == 'T':
                        print("目前组长共有{}人".format(sum1))
                    elif job_ == 'M':
                        print("目前经理共有{}人".format(sum1))
                    for _ in worker[10000:]:
                        if _.job == job_:
                            print(_.uid," - ",_.name)
                index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))

        elif index == 3:
            uid_ = int(input("请输入工号："))
            if uid_>len(worker)-1 or uid_<10000:
                print("该员工不存在!")
                index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
            else:
                print(f"{worker[uid_].name}，工号：{worker[uid_].uid}，当前职位：{worker[uid_].job}{worker[uid_].grade}，当前资薪：{worker[uid_].salary()}")
                temp = worker[uid_].salary()

               
                add_grade = int(input("请输入需要增加的级数："))
                if worker[uid_].job == 'E':
                    max_grade = 10
                    if add_grade + worker[uid_].grade > max_grade:
                        worker[uid_].job = 'T'
                        worker[uid_].grade = 1
                    else:
                        worker[uid_].grade = add_grade + worker[uid_].grade
                        
                elif worker[uid_].job == 'T':
                    max_grade = 6
                    if add_grade + worker[uid_].grade > max_grade:
                        worker[uid_].job = 'M'
                        worker[uid_].grade = 1
                    else:
                        worker[uid_].grade = add_grade + worker[uid_].grade
                        
                elif worker[uid_].job == 'M':
                    max_grade = 3
                    if add_grade + worker[uid_].grade > max_grade:
                        print("没有这个级别")
                        index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
                    else:
                        worker[uid_].grade = add_grade + worker[uid_].grade
                        
                print("升级成功！")
                print(f"{worker[uid_].name}，工号：{worker[uid_].uid}，升级后职位：{worker[uid_].job}{worker[uid_].grade}，升级后资薪：{worker[uid_].salary()}(+{worker[uid_].salary()-temp})")
               

               
            index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))

        elif index == 4:
            uid_ = int(input("请输入工号："))
            if uid_>len(worker)-1 or uid_<10000:
                print("该员工不存在!")
                index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
            else:
                print(f"{worker[uid_].name}，工号：{worker[uid_].uid}，当前职位：{worker[uid_].job}{worker[uid_].grade}，当前资薪：{worker[uid_].salary()}")
                temp = worker[uid_].salary()
               
                add_grade = int(input("请输入需要减少的级数："))
                if worker[uid_].job == 'M':
                    min_grade = 1
                    if  worker[uid_].grade - add_grade < min_grade:
                        worker[uid_].job = 'T'
                        worker[uid_].grade = 6
                    else:
                        worker[uid_].grade = worker[uid_].grade - add_grade

                elif worker[uid_].job == 'T':
                    min_grade = 1
                    if aworker[uid_].grade - add_grade < min_grade:
                        worker[uid_].job = 'E'
                        worker[uid_].grade = 10
                    else:
                        worker[uid_].grade = worker[uid_].grade - add_grade
                        
                elif worker[uid_].job == 'E':
                    min_grade = 1
                    if worker[uid_].grade - add_grade < min_grade:
                        print("没有这个级别")
                        index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
                    else:
                        worker[uid_].grade = worker[uid_].grade - add_grade

            print("降级成功！")
            print(f"{worker[uid_].name}，工号：{worker[uid_].uid}，降级后职位：{worker[uid_].job}{worker[uid_].grade}，降级后资薪：{worker[uid_].salary()}({worker[uid_].salary()-temp})")


               
            index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
   


class Worker:
    def __init__(self,name=None,job=None,grade=None,year=None,uid=None):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
        self.uid = uid

    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)

    def worker_inquire(self):
        print(f"姓名：{self.name}")
        print(f"职位：{self.job}")
        print(f"级别：{self.grade}")
        print(f"工龄：{self.year}")
        print(f"薪资：{self.salary()}")


              

haaljw

1

TZ小宿

我曾经跨过山和大海

exileddesperado

0. 不同类的对象均可使用同一种方法
1. 利用多态可以让不同类的对象执行同一种方法
2. 可以
3.
4. 增强内聚
5. 不属于

0.
uids = iter(range(10000, 100000))
uid_used = []
employees = []

def get_uid(uids):
    uid = int(input("请输入工号："))
    while uid not in uids:
        uid = int(input("工号不存在，请重新输入："))
    return uid

class infoMixin:
    def info(self, name, job, grade, year, uid):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
        self.uid = uid

class checkMixin:
    def check_grade(self):
        if self.job == "E":
            if self.grade > 10 or self.grade < 0:
                self.grade = int(input("超过范围，该职位级别为1~10，请重新输入："))
        elif self.job == "T":
            if self.grade > 6 or self.grade < 0:
                self.grade = int(input("超过范围，该职位级别为1~6，请重新输入："))
        elif self.job == "M":
            if self.grade > 3 or self.grade < 0:
                self.grade = int(input("超过范围，该职位级别为1~3，请重新输入："))

    def up_grade(self, x):
        if self.job == "E":
            if x + self.grade > 10:
                self.job = "T"
                self.grade = 1
            else:
                self.grade += x
        elif self.job == "T":
            if x + self.grade > 6:
                self.job = "M"
                self.grade = 1
            else:
                self.grade += x
        else:
            while x + self.grade > 3:
                x = int(input("超过范围，该职位级别为1~3，请重新输入："))
            self.grade += x

    def down_grade(self, x):
        if self.job == "M":
            if self.grade - x <= 0:
                self.job = "T"
                self.grade = 6
            else:
                self.grade -= x
        elif self.job == "T":
            if self.grade - 2 <= 0:
                self.job = "E"
                self.grade = 10
            else:
                self.grade -= x
        else:
            while x + self.grade <= 0:
                x = int(input("超过范围，该职位级别为1~10，请重新输入："))
            self.grade -= x      


class toolMixin:
    def get_uid(self):
        return self.uid

    def get_name(self):
        return self.name

    def get_job(self):
        return self.job

    def get_grade(self):
        return self.grade

    def get_year(self):
        return self.year

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

class Employee(infoMixin, checkMixin, toolMixin):
    def __init__(self, name, job, grade, year, uid):
        super().info(name, job, grade, year, uid)
        super().check_grade()

class Teamleader(infoMixin, checkMixin, toolMixin):
    def __init__(self, name, job, grade, year, uid):
        super().info(name, job, grade, year, uid)
        super().check_grade()

class Manager(infoMixin, checkMixin, toolMixin):
    def __init__(self, name, job, grade, year, uid):
        super().info(name, job, grade, year, uid)
        super().check_grade()

class Manage:
    def greet(self):
        command = input("1.录入；2.查询；3.升级；4.降级；5.退出")
        return command

    def register(self):
        name = input("姓名：")
        job = input("职位（E.普通员工；T.组长；M.经理）：")
        year = int(input("工龄："))
        grade = int(input("级别："))
        uid = next(uids)
        if job == "E":
            employees.append(Employee(name, job, year, grade, uid))
        elif job == "T":
            employees.append(Teamleader(name, job, year, grade, uid))
        elif job == "M":
            employees.append(Manager(name, job, year, grade, uid))
        uid_used.append(uid)

    def search(self):
        command = input("1.员工查询；2.职位查询：")
        if command == "1":
            uid = get_uid(uid_used)
            for each in employees:
                if each.uid == uid:
                    print(f"姓名：{each.get_name()}\n职位：{each.get_job()}\n级别：{each.get_grade()}\n工龄：{each.get_year()}\n薪资：{each.salary()}")
                    break
        elif command == "2":
            job = input("请输入职位（E.普通员工；T.组长；M.经理）：")
            count = 0
            p = [each for each in employees if each.job == job]
            if job == "E":
                print(f"目前普通员工共{len(p)}人：")
            elif job == "T":
                print(f"目前组长共{len(p)}人：")
            else:
                print(f"目前经理共{len(p)}人：")
            for each in p:
                print(f"{each.uid} --{each.name}")

    def upgrade(self):
        uid = get_uid(uid_used)
        for each in employees:
            if each.uid == uid:
                print(f"{each.name},工号：{each.uid},当前职位：{each.job}{each.grade}，当前薪资：{each.salary()}")
                x = int(input("请输入需要增加的级数："))
                y = each.salary()
                each.up_grade(x)
        print("升级成功！")
        print(f"{each.name},工号：{each.uid},升级后职位：{each.job}{each.grade}，升级后薪资：{each.salary()}(+{each.salary() - y})")

    def downgrade(self):
        uid = get_uid(uid_used)
        for each in employees:
            if each.uid == uid:
                print(f"{each.name},工号：{each.uid},当前职位：{each.job}{each.grade}，当前薪资：{each.salary()}")
                x = int(input("请输入需要降低的级数："))
                y = each.salary()
                each.down_grade(x)
        print("降级成功！")
        print(f"{each.name},工号：{each.uid},降级后职位：{each.job}{each.grade}，降级后薪资：{each.salary()}(-{y - each.salary()})")

def main():
    manage = Manage()
    while 1:
        command = manage.greet()
        if command == "1":
            manage.register()
        elif command == "2":
            manage.search()
        elif command == "3":
            manage.upgrade()
        elif command == "4":
            manage.downgrade()
        elif command == "5":
            break

main()

zhangqinwu

看答案

哈喽你好年

答案

xnl3998

0.允许在子类中定义与父类相同名字的方法
1.可以 运算符的多态
2.不知道
4.增强内聚
5.不属于吧