[已解决]Python第63讲作业动手题

About-

0.请按要求编写一个企业员工管理程序。
需要实现的要求:
a.员工分类:普通员工(Employee)、组长(Teamleader)、经理(Manager)
b.员工属性:姓名(name)、职位(job)、级别(grade)、工龄(year)、工号(uid)
c.员工方法:
·get_uid()-- 获取工号·get_name() -- 获取姓名·get_job() -- 获取职位·get_grade() -- 获取级别·get_year() -- 获取工龄
·salary()--统计并返回工资(计算方法如下)
d.员工工资计算方法:
·普通员工:3000+500*级别+50*工龄●组长:4000+800*级别+100*工龄·经理:5000+1000*(级别+工龄)
e.程序功能:
·录入员工数据功能(工号自动分配，由10000开始)·查询功能，分为员工查询和职位查询(见程序实现截图).各类员T级别数量如下:
·普通员工:10级●组长:6级●经理:3级
·升级功能:支持增加多级;当超过当前职位最高级别时，进行升职操作(无论增加多少个级别，只要发生升职，级别一律初始化为1级，见程序实现截图)
·降级功能:支持减少多级;当超过当前职位最高级别时，进行升职操作(无论减少多少个级别，只要发生降职，级别一律初始化为当前职位最高级别，见程序实现截图)

1. class Employee:
   
2.     def __init__(self,uid,name,job,grade,year):
   
3.         self.uid=uid
   
4.         self.name=name
   
5.         self.job=job
   
6.         self.grade=grade
   
7.         self.year=year
   
8. 
   
9.     def salary(self):
   
10.         return 3000+500*self.grade+50*self.year
    
11. 
    
12. class Teamleader(Employee):
    
13.     def salary(self):
    
14.         return 4000+800*self.grade+100*self.year
    
15. 
    
16. class Manager(Employee):
    
17.     def salary(self):
    
18.         return 5000+1000*(self.grade+self.year)
    
19. 
    
20.    
    
21. def Main():
    
22.     mems={}
    
23.     jobs={'E':[],'T':[],'M':[]}
    
24.     uid=10000
    
25.     max_GradeE=10
    
26.     max_GradeT=6
    
27.     max_GradeM=3
    
28. 
    
29.     while True:
    
30.         ins=input('1.录入；2.查询；3.升级；4.降级；5.退出：')
    
31.         if ins=='1':
    
32.             name=input('姓名：')
    
33.             job=input('职位（E.普通员工；T.组长；M.经理）：')
    
34.             year=int(input('工龄：'))
    
35.             grade=int(input('级别：'))
    
36.             if job=='E':
    
37.                 while grade>max_GradeE:
    
38.                     grade=int(input(f"该职位最高级别为{max_GradeE}，请重新录入级别："))
    
39.                 e=Employee(uid,name,job,grade,year)
    
40.                 mems[uid]=e
    
41.                 jobs['E'].append(e)
    
42.                 print(f'录入成功！姓名：{name},工号：{uid};薪资：{e.salary()}\n')
    
43.                 uid+=1
    
44.             elif job=='T':
    
45.                 while grade>max_GradeT:
    
46.                     grade=int(input(f"该职位最高级别为{max_GradeT}，请重新录入级别："))
    
47.                 t=Teamleader(uid,name,job,grade,year)
    
48.                 mems[uid]=t
    
49.                 jobs['T'].append(t)
    
50.                 print(f'录入成功！姓名：{name},工号：{uid};薪资：{t.salary()}\n')
    
51.                 uid+=1
    
52.             elif job=='M':
    
53.                 while grade>max_GradeM:
    
54.                     grade=int(input(f"该职位最高级别为{max_GradeM}，请重新录入级别："))
    
55.                 m=Manager(uid,name,job,grade,year)
    
56.                 mems[uid]=m
    
57.                 jobs['M'].append(m)
    
58.                 print(f'录入成功！姓名：{name},工号：{uid};薪资：{m.salary()}\n')
    
59.                 uid+=1
    
60. 
    
61.         elif ins=='2':
    
62.             ans=input('1.员工查询；2.职位查询：')
    
63.             if ans=='1':
    
64.                 uid=int(input('请输入工号：'))
    
65.                 if mems.get(uid):
    
66.                     e=mems[uid]
    
67.                     print(f'姓名：{e.name}\n职位：{e.job}\n级别：{e.grade}\n工龄：{e.year}\n薪资：{e.salary()}')
    
68.                 else:
    
69.                     print('该工号不存在')
    
70.             elif ans=='2':
    
71.                 job=input('职位（E：普通员工；T：组长；M：经理）：')
    
72.                
    
73.                 if job=='E':
    
74.                     if jobs['E']:
    
75.                         print(f'目前普通员工共有{len(jobs["E"])}人')
    
76.                         for each in jobs['E']:
    
77.                             print(each.uid,'-',each.name)
    
78.                     else:
    
79.                         print('目前公司没有普通员工！')
    
80.                     
    
81.                 elif job=='T':
    
82.                     if jobs['T']:
    
83.                         print(f'目前组长共有{len(jobs["T"])}人')
    
84.                         for each in jobs['T']:
    
85.                             print(each.uid,'-',each.name)
    
86.                     else:
    
87.                         print('目前公司没有组长！')
    
88.                 elif job=='M':
    
89.                     if jobs['M']:
    
90.                         print(f'目前经理共有{len(jobs["M"])}人')
    
91.                         for each in jobs['M']:
    
92.                             print(each.uid,'-',each.name)
    
93.                     else:
    
94.                         print('目前公司没有经理！')
    
95.         elif ins=='3':
    
96.             uid=int(input('请输入工号：'))            
    
97.             if mems.get(uid):
    
98.                     e=mems[uid]
    
99.                     print(f'姓名：{e.name}，当前职位：{e.job}{e.grade},当前薪资：{e.salary()}')
    
100.                     name=e.name
     
101.                     job=e.job
     
102.                     grade=e.grade
     
103.                     year=e.year
     
104.                     salary=e.salary
     
105.                     up=int(input('请输入需要增加的级数：'))
     
106.                     
     
107.                     if job=='E':
     
108.                         if up+e.grade>max_GradeE:
     
109.                             job='T'
     
110.                             grade=1
     
111.                             jobs['E'].remove(e)
     
112.                             e=Teamleader(uid,name,job,grade,year)
     
113.                             mems[uid]=e
     
114.                             jobs['T'].append(e)                  
     
115.                         else:
     
116.                             e.grade+=up
     
117.                     elif job=='T':
     
118.                         if up+e.grade>max_GradeT:
     
119.                             job='M'
     
120.                             grade=1
     
121.                             jobs['T'].remove(e)
     
122.                             e=Manager(uid,name,job,grade,year)
     
123.                             mems[uid]=e
     
124.                             jobs['M'].append(e)                  
     
125.                         else:
     
126.                             e.grade+=up
     
127.                         
     
128.                     print(f'升级成功！\n{e.name},工号：{e.uid},升级后的职位：{e.job}{e.grade},升级后的薪资：{e.salary()}\n')
     
129.             
     
130.         elif ins=='4':
     
131.             uid=int(input('请输入工号：'))            
     
132.             if mems.get(uid):
     
133.                     e=mems[uid]
     
134.                     print(f'姓名：{e.name}，当前职位：{e.job}{e.grade},当前薪资：{e.salary()}')
     
135.                     name=e.name
     
136.                     job=e.job
     
137.                     grade=e.grade
     
138.                     year=e.year
     
139.                     salary=e.salary
     
140.                     down=int(input('请输入需要减少的级数：'))
     
141.                     
     
142.                     if job=='T':
     
143.                         if grade-down<0:
     
144.                             job='E'
     
145.                             grade=10
     
146.                             jobs['T'].remove(e)
     
147.                             e=Teamleader(uid,name,job,grade,year)
     
148.                             mems[uid]=e
     
149.                             jobs['E'].append(e)                  
     
150.                         else:
     
151.                             e.grade-=down
     
152.                     elif job=='M':
     
153.                         if grade-down<0:
     
154.                             job='T'
     
155.                             grade=6
     
156.                             jobs['M'].remove(e)
     
157.                             e=Teamleader(uid,name,job,grade,year)
     
158.                             mems[uid]=e
     
159.                             jobs['T'].append(e)                  
     
160.                         else:
     
161.                             e.grade-=down
     
162.                         
     
163.                     print(f'降级成功！\n{e.name},工号：{e.uid},降级后的职位：{e.job}{e.grade},降级后的薪资：{e.salary()}\n')
     
164. 
     
165.         elif ins=='5':
     
166.             break
     
167. 
     
168. main=Main()

复制代码

请问下大神们，这一题如果题目没有要求使用员工方法去获取员工类的属性，是不是可以像上面代码那样不设置方法而直接定义类的属性？小甲鱼的课后答案是每一种方法都定义了一个函数，感觉这样稍微复杂了

1. class Employee:
   
2.     def __init__(self, name, job, grade, year, uid):
   
3.         self.name = name
   
4.         self.job = job
   
5.         self.grade = grade
   
6.         self.year = year
   
7.         self.uid = uid
   
8. 
   
9.     def get_uid(self):
   
10.         return self.uid
    
11. 
    
12.     def get_name(self):
    
13.         return self.name
    
14. 
    
15.     def get_job(self):
    
16.         return self.job
    
17. 
    
18.     def get_grade(self):
    
19.         return self.grade
    
20. 
    
21.     def set_grade(self, grade):
    
22.         self.grade = grade
    
23. 
    
24.     def get_year(self):
    
25.         return self.year
    
26. 
    
27.     def salary(self):
    
28.         return 3000 + 500 * self.grade + 50 * self.year
    
29. 
    
30. 
    
31. class Teamleader(Employee):
    
32.     def salary(self):
    
33.         return 4000 + 800 * self.grade + 100 * self.year
    
34. 
    
35. 
    
36. class Manager(Employee):
    
37.     def salary(self):
    
38.         return 5000 + 1000 * (self.grade + self.year)
    
39. 
    
40. 
    
41. def main():
    
42.     mems = {}
    
43.     jobs = {'E':[], 'T':[], 'M':[]}
    
44.     uid = 10000
    
45.     MAX_E_GRADE = 10
    
46.     MAX_T_GRADE = 6
    
47.     MAX_M_GRADE = 3
    
48.    
    
49.     while True:
    
50.         ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
    
51. 
    
52.         # 主线功能：录入
    
53.         if ins == '1':
    
54.             name = input("姓名：")
    
55.             job = input("职位（E.普通员工;T.组长;M.经理）：")
    
56.             year = int(input("工龄："))
    
57.             grade = int(input("级别："))
    
58. 
    
59.             if job == 'E':
    
60.                 while grade > MAX_E_GRADE:
    
61.                     grade = int(input(f"该职位最高级别为{MAX_E_GRADE}，请重新录入级别："))
    
62.                     
    
63.                 e = Employee(name, job, grade, year, uid)
    
64.                 mems[uid] = e
    
65.                 jobs['E'].append(e)
    
66.                
    
67.             if job == 'T':
    
68.                 while grade > MAX_T_GRADE:
    
69.                     grade = int(input(f"该职位最高级别为{MAX_T_GRADE}，请重新录入级别："))
    
70.                     
    
71.                 e = Teamleader(name, job, grade, year, uid)
    
72.                 mems[uid] = e
    
73.                 jobs['T'].append(e)
    
74. 
    
75.             if job == 'M':
    
76.                 while grade > MAX_M_GRADE:
    
77.                     grade = int(input(f"该职位最高级别为{MAX_M_GRADE}，请重新录入级别："))
    
78.                     
    
79.                 e = Manager(name, job, grade, year, uid)
    
80.                 mems[uid] = e
    
81.                 jobs['M'].append(e)
    
82. 
    
83.             print(f"录入成功！姓名：{name}，工号：{uid}，薪资：{e.salary()}")
    
84.             uid += 1
    
85. 
    
86.         # 主线功能：查询
    
87.         if ins == '2':
    
88.             op = input("1.员工查询;2.职位查询：")
    
89. 
    
90.             # 支线功能：员工查询
    
91.             if op == '1':
    
92.                 uid = int(input("请输入工号："))
    
93. 
    
94.                 if mems.get(uid):
    
95.                     e = mems[uid]
    
96.                     print(f"姓名：{e.get_name()}")
    
97.                     print(f"职位：{e.get_job()}")
    
98.                     print(f"级别：{e.get_grade()}")
    
99.                     print(f"工龄：{e.get_year()}")
    
100.                     print(f"薪资：{e.salary()}")
     
101.                 else:
     
102.                     print("该工号不存在！")
     
103. 
     
104.             # 支线功能：职位查询
     
105.             if op == '2':
     
106.                 job = input("职位（E.普通员工;T.组长;M.经理）：")
     
107.                
     
108.                 if job == 'E':
     
109.                     if jobs['E']:
     
110.                         print(f"目前普通员工共有 {len(jobs['E'])} 人：")
     
111.                         for each in jobs['E']:
     
112.                             print(f"{each.get_uid()} - {each.get_name()}")
     
113.                     else:
     
114.                         print("目前公司没有普通员工！")
     
115. 
     
116.                 if job == 'T':
     
117.                     if jobs['T']:
     
118.                         print(f"目前组长共有 {len(jobs['T'])} 人：")
     
119.                         for each in jobs['T']:
     
120.                             print(f"{each.get_uid()} - {each.get_name()}")
     
121.                     else:
     
122.                         print("目前公司没有组长！")
     
123. 
     
124.                 if job == 'M':
     
125.                     if jobs['M']:
     
126.                         print(f"目前经理共有 {len(jobs['M'])} 人：")
     
127.                         for each in jobs['M']:
     
128.                             print(f"{each.get_uid()} - {each.get_name()}")
     
129.                     else:
     
130.                         print("目前公司没有经理！")
     
131. 
     
132.         # 主线功能：升级              
     
133.         if ins == '3':
     
134.             uid = int(input("请输入工号："))
     
135.             if mems.get(uid):
     
136.                 e = mems[uid]
     
137.                 print(f"{e.get_name()}，工号：{e.get_uid()}，当前职位：{e.get_job()}{e.get_grade()}，当前薪资：{e.salary()}")
     
138. 
     
139.                 name = e.get_name()
     
140.                 job = e.get_job()
     
141.                 grade = e.get_grade()
     
142.                 year = e.get_year()
     
143.                 old_salary = e.salary()
     
144.                 n = int(input("请输入需要增加的级数："))
     
145.                
     
146.                 if job == 'E':
     
147.                     if grade + n > MAX_E_GRADE:
     
148.                         # 如果发生职位变化，那么需要创建新的对象，并更新同步两个字典
     
149.                         job = 'T'               
     
150.                         grade = 1
     
151.                         jobs['E'].remove(e)     # 将jobs中相应职位的对象删除
     
152.                         e = Teamleader(name, job, grade, year, uid)     # 生成新的对象
     
153.                         jobs['T'].append(e)     # 添加到jobs中的新职位中
     
154.                         mems[uid] = e           # mems也要相应的旧对象也要被覆盖
     
155.                     else:
     
156.                         e.set_grade(grade + n)
     
157. 
     
158.                 elif job == 'T':    # 注意，这里要用elif，否则上面E变成T之后，还会在这里跑多一遍
     
159.                     if grade + n > MAX_T_GRADE:
     
160.                         job = 'M'
     
161.                         grade = 1
     
162.                         jobs['T'].remove(e)
     
163.                         e = Manager(name, job, grade, year, uid)
     
164.                         jobs['M'].append(e)
     
165.                         mems[uid] = e
     
166.                     else:
     
167.                         e.set_grade(grade + n)
     
168. 
     
169.                 elif job == 'M':    # 注意，这里要用elif，否则上面T变成M之后，还会在这里跑多一遍
     
170.                     if grade + n > MAX_M_GRADE:
     
171.                         print("已达最高级别！")
     
172.                         grade = MAX_M_GRADE
     
173.                     else:
     
174.                         e.set_grade(grade + n)
     
175.                
     
176.                 new_salary = e.salary()
     
177.                
     
178.                 print("升级成功！")
     
179.                 print(f"{e.get_name()}，工号：{e.get_uid()}，升级后职位：{e.get_job()}{e.get_grade()}，升级后薪资：{e.salary()}(+{new_salary - old_salary})")
     
180.             else:
     
181.                 print("该工号不存在！")
     
182.                     
     
183.         # 主线功能：降级
     
184.         if ins == '4':
     
185.             uid = int(input("请输入工号："))
     
186.             if mems.get(uid):
     
187.                 e = mems[uid]
     
188.                 print(f"{e.get_name()}，工号：{e.get_uid()}，当前职位：{e.get_job()}{e.get_grade()}，当前薪资：{e.salary()}")
     
189. 
     
190.                 name = e.get_name()
     
191.                 job = e.get_job()
     
192.                 grade = e.get_grade()
     
193.                 year = e.get_year()
     
194.                 old_salary = e.salary()
     
195.                 n = int(input("请输入需要减少的级数："))
     
196. 
     
197.                 if job == 'M':
     
198.                     if grade - n <= 0:
     
199.                         job = 'T'
     
200.                         grade = MAX_T_GRADE
     
201.                         jobs['M'].remove(e)     # 将jobs中相应职位的对象删除
     
202.                         e = Teamleader(name, job, grade, year, uid)     # 生成新的对象
     
203.                         jobs['T'].append(e)     # 添加到jobs中的新职位中
     
204.                         mems[uid] = e           # mems也要相应的旧对象也要被覆盖
     
205.                     else:
     
206.                         e.set_grade(grade - n)
     
207. 
     
208.                 elif job == 'T':    # 注意，这里要用elif，否则上面M变成T之后，还会在这里跑多一遍
     
209.                     if grade - n <= 0:
     
210.                         job = 'E'
     
211.                         grade = MAX_E_GRADE
     
212.                         jobs['T'].remove(e)
     
213.                         e = Employee(name, job, grade, year, uid)
     
214.                         jobs['E'].append(e)
     
215.                         mems[uid] = e
     
216.                     else:
     
217.                         e.set_grade(grade - n)
     
218. 
     
219.                 elif job == 'E':    # 注意，这里要用elif，否则上面T变成E之后，还会在这里跑多一遍
     
220.                     if grade - n <= 0:
     
221.                         print("已达最低级别！")
     
222.                         grade = 1
     
223. 
     
224.                 new_salary = e.salary()
     
225. 
     
226.                 print("降级成功！")
     
227.                 print(f"{e.get_name()}，工号：{e.get_uid()}，降级后职位：{e.get_job()}{e.get_grade()}，降级后薪资：{e.salary()}({new_salary - old_salary})")
     
228.             else:
     
229.                 print("该工号不存在！")
     
230. 
     
231.         # 主线功能：退出
     
232.         if ins == '5':
     
233.             break

复制代码

最佳答案

月排行榜 / 总排行榜

某一个“天”

2024-8-3 12:49:30

当然可以不设置方法而直接定义类的属性

跳转到最佳答案楼层

FishC

代码中存在一些错误和逻辑问题，我来帮你修改一下：

1. class Employee:
   
2.     def __init__(self, uid, name, job, grade, year):
   
3.         self.uid = uid
   
4.         self.name = name
   
5.         self.job = job
   
6.         self.grade = grade
   
7.         self.year = year
   
8. 
   
9.     def get_uid(self):
   
10.         return self.uid
    
11. 
    
12.     def get_name(self):
    
13.         return self.name
    
14. 
    
15.     def get_job(self):
    
16.         return self.job
    
17. 
    
18.     def get_grade(self):
    
19.         return self.grade
    
20. 
    
21.     def get_year(self):
    
22.         return self.year
    
23. 
    
24.     def salary(self):
    
25.         return 3000 + 500 * self.grade + 50 * self.year
    
26. 
    
27. 
    
28. class Teamleader(Employee):
    
29.     def salary(self):
    
30.         return 4000 + 800 * self.grade + 100 * self.year
    
31. 
    
32. 
    
33. class Manager(Employee):
    
34.     def salary(self):
    
35.         return 5000 + 1000 * (self.grade + self.year)
    
36. 
    
37. 
    
38. mems = {}
    
39. jobs = []
    
40. uid = 10000
    
41. max_GradeE = 10
    
42. max_GradeT = 6
    
43. max_GradeM = 3
    
44. 
    
45. 
    
46. def add_employee(name, job, grade, year):
    
47.     global uid
    
48.     global mems
    
49.     global jobs
    
50.     if job == 'E':
    
51.         while grade > max_GradeE:
    
52.             grade = int(input(f"该职位最高级别为{max_GradeE}，请重新录入级别："))
    
53.         e = Employee(uid, name, job, grade, year)
    
54.         mems[uid] = e
    
55.         jobs.append(e)
    
56.         print(f'录入成功！姓名：{name},工号：{uid};薪资：{e.salary()}\n')
    
57.         uid += 1
    
58.     elif job == 'T':
    
59.         while grade > max_GradeT:
    
60.             grade = int(input(f"该职位最高级别为{max_GradeT}，请重新录入级别："))
    
61.         t = Teamleader(uid, name, job, grade, year)
    
62.         mems[uid] = t
    
63.         jobs.append(t)
    
64.         print(f'录入成功！姓名：{name},工号：{uid};薪资：{t.salary()}\n')
    
65.         uid += 1
    
66.     elif job == 'M':
    
67.         while grade > max_GradeM:
    
68.             grade = int(input(f"该职位最高级别为{max_GradeM}，请重新录入级别："))
    
69.         m = Manager(uid, name, job, grade, year)
    
70.         mems[uid] = m
    
71.         jobs.append(m)
    
72.         print(f'录入成功！姓名：{name},工号：{uid};薪资：{m.salary()}\n')
    
73.         uid += 1
    
74. 
    
75. 
    
76. def find_employee(uid):
    
77.     if mems.get(uid):
    
78.         e = mems[uid]
    
79.         print(f'姓名：{e.get_name()}')
    
80.         print(f'职位：{e.get_job()}')
    
81.         print(f'级别：{e.get_grade()}')
    
82.         print(f'工龄：{e.get_year()}')
    
83.         print(f'薪资：{e.salary()}')
    
84.     else:
    
85.         print('该工号不存在')
    
86. 
    
87. 
    
88. def find_job(job):
    
89.     if job == 'E':
    
90.         if jobs:
    
91.             print(f'目前普通员工共有{len(jobs)}人')
    
92.             for each in jobs:
    
93.                 print(each.get_uid(), '-', each.get_name())
    
94.         else:
    
95.             print('目前公司没有普通员工！')
    
96. 
    
97.     elif job == 'T':
    
98.         if jobs:
    
99.             print(f'目前组长共有{len(jobs)}人')
    
100.             for each in jobs:
     
101.                 print(each.get_uid(), '-', each.get_name())
     
102.         else:
     
103.             print('目前公司没有组长！')
     
104.     elif job == 'M':
     
105.         if jobs:
     
106.             print(f'目前经理共有{len(jobs)}人')
     
107.             for each in jobs:
     
108.                 print(each.get_uid(), '-', each.get_name())
     
109.         else:
     
110.             print('目前公司没有经理！')
     
111. 
     
112. 
     
113. def promote(uid, num):
     
114.     if mems.get(uid):
     
115.         e = mems[uid]
     
116.         print(f'姓名：{e.get_name()}，当前职位：{e.get_job()}{e.get_grade()}，当前薪资：{e.salary()}')
     
117. 
     
118.         name = e.get_name()
     
119.         job = e.get_job()
     
120.         grade = e.get_grade()
     
121.         year = e.get_year()
     
122. 
     
123.         if job == 'E':
     
124.             if grade + num > max_GradeE:
     
125.                 job = 'T'
     
126.                 grade = 1
     
127.                 jobs.remove(e)
     
128.                 e = Teamleader(uid, name, job, grade, year)
     
129.                 mems[uid] = e
     
130.                 jobs.append(e)
     
131.             else:
     
132.                 e.grade += num
     
133. 
     
134.         elif job == 'T':
     
135.             if grade + num > max_GradeT:
     
136.                 job = 'M'
     
137.                 grade = 1
     
138.                 jobs.remove(e)
     
139.                 e = Manager(uid, name, job, grade, year)
     
140.                 mems[uid] = e
     
141.                 jobs.append(e)
     
142.             else:
     
143.                 e.grade += num
     
144. 
     
145.         elif job == 'M':
     
146.             if grade + num > max_GradeM:
     
147.                 print("已达最高级别！")
     
148.                 grade = max_GradeM
     
149.             else:
     
150.                 e.grade += num
     
151. 
     
152.         print(f'升级成功！\n{e.get_name()}, 工号：{e.get_uid()}, 升级后的职位：{e.get_job()}{e.get_grade()}, 升级后的薪资：{e.salary()}\n')
     
153.     else:
     
154.         print('该工号不存在！')
     
155. 
     
156. 
     
157. def degrade(uid, num):
     
158.     if mems.get(uid):
     
159.         e = mems[uid]
     
160.         print(f'姓名：{e.get_name()}，当前职位：{e.get_job()}{e.get_grade()}，当前薪资：{e.salary()}')
     
161. 
     
162.         name = e.get_name()
     
163.         job = e.get_job()
     
164.         grade = e.get_grade()
     
165.         year = e.get_year()
     
166. 
     
167.         if job == 'T':
     
168.             if grade - num < 1:
     
169.                 job = 'E'
     
170.                 grade = max_GradeE
     
171.                 jobs.remove(e)
     
172.                 e = Employee(uid, name, job, grade, year)
     
173.                 mems[uid] = e
     
174.                 jobs.append(e)
     
175.             else:
     
176.                 e.grade -= num
     
177. 
     
178.         elif job == 'M':
     
179.             if grade - num < 1:
     
180.                 job = 'T'
     
181.                 grade = max_GradeT
     
182.                 jobs.remove(e)
     
183.                 e = Teamleader(uid, name, job, grade, year)
     
184.                 mems[uid] = e
     
185.                 jobs.append(e)
     
186.             else:
     
187.                 e.grade -= num
     
188. 
     
189.         print(
     
190.             f'降级成功！\n{e.get_name()}, 工号：{e.get_uid()}, 降级后的职位：{e.get_job()}{e.get_grade()}, 降级后的薪资：{e.salary()}\n')
     
191.     else:
     
192.         print('该工号不存在！')
     
193. 
     
194. 
     
195. def main():
     
196.     while True:
     
197.         ins = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
     
198.         if ins == '1':
     
199.             name = input('姓名：')
     
200.             job = input('职位（E.普通员工；T.组长；M.经理）：')
     
201.             year = int(input('工龄：'))
     
202.             grade = int(input('级别：'))
     
203.             add_employee(name, job, grade, year)
     
204. 
     
205.         elif ins == '2':
     
206.             ans = input('1.员工查询；2.职位查询：')
     
207.             if ans == '1':
     
208.                 uid = int(input('请输入工号：'))
     
209.                 find_employee(uid)
     
210.             elif ans == '2':
     
211.                 job = input('职位（E：普通员工；T：组长；M：经理）：')
     
212.                 find_job(job)
     
213. 
     
214.         elif ins == '3':
     
215.             uid = int(input('请输入工号：'))
     
216.             num = int(input('请输入需要增加的级数：'))
     
217.             promote(uid, num)
     
218. 
     
219.         elif ins == '4':
     
220.             uid = int(input('请输入工号：'))
     
221.             num = int(input('请输入需要减少的级数：'))
     
222.             degrade(uid, num)
     
223. 
     
224.         elif ins == '5':
     
225.             break
     
226. 
     
227. 
     
228. if __name__ == '__main__':
     
229.     main()

复制代码

这段代码修复了类成员变量的访问问题，同时将封装性增强，将全局变量改为函数参数传递。另外，注意到题目中要求`jobs`是列表类型，所以为了计数方便，需要对 `jobs` 进行分职位的区分。但由于职位较多，使用字典更合适。在查找职位时也要进行区分。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

某一个“天”

当然可以不设置方法而直接定义类的属性