1
0.
面向对象的多态是通过继承的重写和不同对象调用同名方法实现的。
1.
一类代码可以实现多种功能，让代码更简洁。
2.
可以，这就是多态
多态是指运算符，函数，对象在不同的状态下具有不同的作用。
3.
美国印第安纳州的诗人詹姆斯·惠特科姆·莱利（James Whitcomb Riley, 1849 ~ 1916）的诗句
“如果有个东西看起来像鸭子，游的像鸭子，叫的像鸭子，把它应该就是个鸭子。”
4.
提高了内聚，因为只要实质一样，形式不一样也可以实现某这功能，提高了内聚。
5.
不是多态
多态是指不同的场景下产生不同的作用。这里是将z参数提前赋值，场景本身没有变化，所以不算多态。
动动手
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 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):
if job == 'E':
mon = 3000 + 500 * self.grade + 50 * self.year
elif job == 'T':
mon = 4000 + 800 * self.grade + 100 * self.year
elif job == 'M':
mon = 5000 + 1000 * (self.grade + self.year)
return mon
def main():
worker = []
uid = 10000
while True:
print(uid)
s = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
if s == '1':
name = input('姓名：')
job = input('职位（E.普通员工；T.组长；M.经理）：')
while job not in ('E','T','M'):
job = input('只能输入E.T.M,请重新输入:')
year = int(input('工龄：'))
grade = int(input('级别：'))
if job == 'E' :
while grade <= 0 or grade > 10:
grade = int(input('该职位最高级别为10z最小为1，请重新输入：'))
elif job == 'T':
while grade <= 0 or grade > 6:
grade = int(input('该职位最高级别为6最小为1，请重新输入：'))
else:
while grade <= 0 or grade > 3:
grade = int(input('该职位最高级别为3最小为1，请重新输入：'))
worker.append(Employee(name,job,grade,year,uid))
print(f'录入成功，姓名：{name},工号:{uid},薪资：{worker[-1].salary(job)}')
uid += 1
elif s == '2':
print(uid)
find = input('1.员工查询；2.职位查询：')
if find == '1':
yuid = int(input('请输入工号：'))
for i in worker:
if i.uid == yuid:
print(f'姓名:{i.name}',f'职位:{i.job}',f'级别:{i.grade}',f'工龄:{i.year}',f'薪资:{i.salary(i.job)}',sep = '\n')
break
else:
print('该工号不存在')
elif find == '2':
w = []
job = input('职位（E.普通员工；T.组长；M.经理）：')
while job != 'E' and job != 'T' and job != 'M':
job = input('输入错误，请重新输入：')
for j in worker:
if j.job == job:
w.append(str(j.uid)+'-'+j.name)
if len(w) == 0:
if job == 'E':
print('目前公司么有普通员工！')
elif job == 'T':
print('目前公司没有组长！')
elif job == 'M':
print('目前公司没有经理！')
else:
if job == 'E':
a = '普通员工'
elif job == 'T':
a = '组长'
elif job == 'M':
a = '经理'
print(f'目前{a}共有{len(w)}人：')
for k in w:
print(k)
w.clear()
elif s == '3':
yuid = int(input('请输入工号：'))
worker.append(' ')
for l in worker:
if l.uid == yuid:
print(f'{l.name}，工号:{l.uid},当前职位：{l.job + str(l.grade)},当前薪资:{l.salary(l.job)}')
break
else:
print('该工号不存在')
gra = int(input('请输入需要增加的级数:'))
if gra < 0:
print('只能输入正整数或0')
l.grade += gra
if l.job == "E" and l.grade > 10:
l.job = "T"
l.grade = 1
elif l.job == "T" and l.grade > 6:
l.job = "M"
l.grade = 1
elif l.job == "M" and l.grade > 3:
l.job = "M"
l.grade = 3
print('升级成功')
print(f'{l.name} 工号:{l.uid},升级后的职位{l.job + str(l.grade)},升级后的薪资:{l.salary(l.job)}')
worker.pop()
elif s == '4':
yuid = int(input('请输入工号：'))
worker.append(' ')
for l in worker:
if l.uid == yuid:
print(f'{l.name}，工号:{l.uid},当前职位：{l.job + str(l.grade)},当前薪资:{l.salary(l.job)}')
break
else:
print('该工号不存在')
gra = int(input('请输入需要减少的级数:'))
if gra < 0:
print('只能输入正整数或0')
l.grade -= gra
if l.job == "M" and l.grade < 1:
l.job = "T"
l.grade = 6
elif l.job == "T" and l.grade < 1:
l.job = "E"
l.grade = 10
elif l.job == "E" and l.grade < 1:
l.job = "E"
l.grade = 1
print('降级成功')
print(f'{l.name} 工号:{l.uid},升级后的职位{l.job + str(l.grade)},升级后的薪资:{l.salary(l.job)}')
worker.pop()
elif s == "5":
break
main()
1
{:5_106:}
0
同样的
动手
class PromoteCheckMixin:
def promotecheck(self, cate, jo, gra):
if cate:
if (gra >= 3 and jo == 'M'):
print('已是最高级，无法升级。')
return jo, 3
elif gra >= 6 and jo == 'T':
jo = 'M'
return jo, 1
elif gra >= 10 and jo == 'E':
jo = 'T'
return jo, 1
else:
return jo, gra
else:
if gra <= 0 and jo == 'E':
print('已是最低级，无法降级。')
return jo, 1
elif gra <= 0 and jo == 'M':
jo = 'T'
gra = 6
elif gra <= 0 and jo == 'T':
jo = 'E'
gra = 10
return jo, gra
# 员工分类
class Emp_category:
def __init__(self):
self.Employee =
self.Teamleader =
self.Manager =
# 员工信息类
class Employee(Emp_category):
def __init__(self, name, job, grade, year, uid):
super().__init__()
self.name = name
self.job = job
self.grade = grade
self.year = year
self.uid = uid
self.sala = self.salary()
#员工方法
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):
base = self.Employee if self.job == 'E' else self.Teamleader if self.job == 'T' else self.Manager
return base + base*self.grade + base*self.year
# 功能管理类
class Manage(PromoteCheckMixin):
def __init__(self):
self.employees = {}
self.uid = 10000
# 登录初始化
def welcome(self):
ins = input('1.录入 2.查询 3.升级 4.降级 5.退出')
while ins:
if ins == '1':
self.typein()
if ins == '2':
self.search()
if ins == '3':
self.upgrade()
if ins == '4':
self.downgrade()
if ins == '5':
print('退出系统。')
break
print()
ins = input('1.录入 2.查询 3.升级 4.降级 5.退出')
# 录入
def typein(self):
name = input('姓名：')
job = input('职位（E.普通员工 T.组长 M.经理）：')
year = int(input('工龄：'))
grade = int(input('级别：'))
while 1:
if job == 'E' and grade > 10:
grade = int(input('该职位最高级别为10，请重新录入级别：'))
if job == 'T' and grade > 6:
grade = int(input('该职位最高级别为6，请重新输入级别：'))
if job == 'M' and grade > 3:
grade = int(input('该职位最高级别为3，请重新输入级别：'))
break
emp = Employee(name, job, grade, year, self.uid)
self.employees = emp
print(self.employees)
print(self.employees.sala)
print(f'录入成功！姓名：{self.employees.name}，工号：{self.uid}，薪资：{self.employees.sala}')
self.uid += 1
# 查询
def search(self):
comm = input('1.工号查询 2.职位查询：')
if comm == '1':
userid = int(input('请输入工号：'))
while userid not in self.employees.keys():
userid = int(input('工号不存在，请重新输入：'))
print(f'姓名：{self.employees.name}')
print(f'职位：{self.employees.job}')
print(f'级别：{self.employees.grade}')
print(f'工龄：{self.employees.year}')
print(f'薪资：{self.employees.salary()}')
else:
jobtem = input('职位（E.普通员工 T.组长 M.经理）：')
jobtitle = '普通员工' if jobtem=='E' else '组长' if jobtem=='T' else '经理'
count = 0
personlist = []
for each in self.employees:
if self.employees.job == jobtem:
count += 1
personlist.append(' - '.join(.uid),self.employees.name]))
print(f'目前{jobtitle}共有 {count} 人')
for i in personlist:
print(i)
# 升级
def upgrade(self):
userid = int(input('请输入工号：'))
while userid not in self.employees.keys():
userid = int(input('工号不存在，请重新输入：'))
print(f'{self.employees.name}，工号：{userid}，当前职位：{self.employees.job}+{self.employees.grade}，当前薪资：{self.employees.salary()}')
up = int(input('请输入需要增加的级数：'))
mark = 1
oldsala = self.employees.salary()
self.employees.grade += up
res = self.promotecheck(mark, self.employees.job, self.employees.grade)
self.employees.job = res
self.employees.grade = res
print('升级成功！')
print(f'{self.employees.get_name()}，工号：{userid}，升级后职位：{self.employees.get_job()}+{self.employees.get_grade()}，升级后薪资：{self.employees.salary()}（+{self.employees.salary() - oldsala}）')
# 降级
def downgrade(self):
userid = int(input('请输入工号：'))
while not userid in self.employees.keys():
userid = input('工号不存在，请重新输入：')
print(f'{self.employees.name}，工号：{userid}，当前职位：{self.employees.job}+{self.employees.grade}，当前薪资：{self.employees.salary()}')
down = int(input('请输入需要减少的级数：'))
mark = 0
oldsala = self.employees.salary()
self.employees.grade -= down
res = self.promotecheck(mark, self.employees.job, self.employees.grade)
self.employees.job = res
self.employees.grade = res
print('降级成功！')
print(f'{self.employees.get_name()}，工号：{userid}，降级后职位：{self.employees.get_job()}+{self.employees.get_grade()}，降级后薪资：{self.employees.salary()}({self.employees.salary() - oldsala})')
def main():
e = Manage()
e.welcome()
main()
已思考
{:10_269:}
1
1
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 = 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) != 0:
print(f"目前普通员工共有{len(self.Managerdict)}人：")
for i in self.Managerdict:
print(f"{i} - {self.Managerdict.name}", "\n")
else:
self.__dict = {"E":"普通员工", "T":"组长", "M":"经理"}
print(f"目前公司没有{self.__dict}!", "\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.job = self.job
i.grade = self.grade
super().salarycompute(i.get(self.__uid).job, i.get(self.__uid).grade, i.get(self.__uid).year)
i.salary = self.salary
self.now_salary = i.get(self.__uid).salary
self.__updatedict = i.pop(self.__uid)
self.Managerdict = 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.job = self.job
i.grade = self.grade
super().salarycompute(i.get(self.__uid).job, i.get(self.__uid).grade, i.get(self.__uid).year)
i.salary = self.salary
self.now_salary = i.get(self.__uid).salary
self.__updatedict = i.pop(self.__uid)
self.Managerdict = 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()
来了
{:10_279:}
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.不算吧，只是做了默认参数的功能
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. class Men:
uid = 10000
def __init__(self, name = None, job = None, grade = 0, year = 0):
self.name = name
self.job = job
self.grade = grade
self.year = year
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 get_uid(self):
return self.uid
def p(self):
print(self.gather.__dict__)
#-----------------------------------------------------------------------------------------------
class Employee(Men):
gather = {}
def salary(self, grade, year):
return (3000 + 500 * grade + 50 * year)
class Teamleader(Men):
gather = {}
def salary(self, grade, year):
return (4000 + 800 * grade + 100 * year)
class Manager(Men):
gather = {}
def salary(self, grade, year):
return (5000 + 1000 * (grade + year))
#-----------------------------------------------------------------------------------------------
def get_salary(job, grade, year):
if job == "E":
s = Employee()
while grade > 10 or grade <= 0:
grade = int(input("该职位最高级别为10，请重新输入:"))
if job == "T":
s = Teamleader()
while grade > 6 or grade <= 0:
grade = int(input("该职位最高级别为6，请重新输入:"))
if job == "M":
s = Manager()
while grade > 3 or grade <= 0:
grade = int(input("该职位最高级别为3，请重新输入:"))
return (s.salary(grade, year), grade)
def get_group(job,men):
if job == "E":
s = Employee()
s.gather = men
if job == "T":
s = Teamleader()
s.gather = men
if job == "M":
s = Manager()
s.gather = men
#-----------------------------------------------------------------------------------------------
class Mange(Men):
gather = {}
def lu_ru(self):
name = self.get_name()
job = self.get_job()
year = self.get_year()
grade = self.get_grade()
sal, grade = get_salary(job, grade, year)
men = Men(name, job, grade, year)
men.salary = sal
self.gather = men
get_group(job,men)
print(self.gather.__dict__)
Men.uid += 1
def cha_xu_01(self):
gong_hao = int(input("请输入工号："))
print(self.gather)
if not self.gather.get(gong_hao):
print("工号不存在！")
else:
print("姓名：", self.gather.name)
print("职位：", self.gather.job)
print("级别：", self.gather.grade)
print("工龄：", self.gather.year)
print("薪资：", self.gather.salary)
def cha_xu_02(self):
zhi_wei = input("职位（E.普通员工；T.组长；M.经理）:")
if zhi_wei == "E":
s = Employee()
print(f"目前普通员工有{ len(s.gather)}人")
for i in s.gather:
print("工号：", i, "姓名：", s.gather.name)
elif zhi_wei == "T":
s = Teamleader()
print(f"目前组长有{ len(s.gather)}人")
elif jzhi_weiob == "M":
s = Manager()
print(f"目前经理有{ len(s.gather)}人")
else:
print("职位不存在！")
def cha_xu(self):
one_or_two = int(input("1.员工查询；2.职位查询："))
if one_or_two == 1:
self.cha_xu_01()
elif one_or_two == 2:
self.cha_xu_02()
def sheng_zhi(self):
num = int(input("请输入工号："))
if self.gather.get(num):
print(f"{self.gather.name}, 工号：{num}， 当前职位{self.gather.job}{self.gather.grade}, 当前薪资：{self.gather.salary}")
else:
print("工号不存在！")
up_num = int(input("请输入需要增加的级数："))
if self.gather.job == "E":
base = self.gather.grade + up_num
if base > 10:
self.gather.job = "T"
self.gather.grade = 1
sal, grade = get_salary(self.gather.job, self.gather.grade, self.gather.year)
self.gather.salary = sal
print("升职成功！")
print(f"{self.gather.name}, 工号：{num}， 升职后职位{self.gather.job}{self.gather.grade}, 升职后薪资：{self.gather.salary}")
return
else:
self.gather.grade = base
sal, grade = get_salary(self.gather.job, self.gather.grade, self.gather.year)
self.gather.salary = sal
print("升职成功！")
print(f"{self.gather.name}, 工号：{num}， 升职后职位:{self.gather.job}{self.gather.grade}, 升职后薪资：{self.gather.salary}")
return
if self.gather.job == "T":
base = self.gather.grade + up_num
if base > 6:
self.gather.job = "M"
self.gather.grade = 1
sal, grade = get_salary(self.gather.job, self.gather.grade, self.gather.year)
self.gather.salary = sal
print("升职成功！")
print(f"{self.gather.name},工号：{num}，升职后职位:{self.gather.job}{self.gather.grade}, 升职后薪资：{self.gather.salary}")
return
else:
self.gather.grade = base
sal, grade = get_salary(self.gather.job, self.gather.grade, self.gather.year)
self.gather.salary = sal
print("升职成功！")
print(f"{self.gather.name}, 工号：{num}， 升职后职位:{self.gather.job}{self.gather.grade}, 升职后薪资：{self.gather.salary}")
return
if self.gather.job == "M":
base = self.gather.grade + up_num
if base > 3:
self.gather.grade = 3
sal, grade = get_salary(self.gather.job, self.gather.grade, self.gather.year)
self.gather.salary = sal
print("升职成功！已是最高职位了")
print(f"{self.gather.name}, 工号：{num}， 升职后职位{self.gather.job}{self.gather.grade}, 升职后薪资：{self.gather.salary}")
return
else:
self.gather.grade = base
sal, grade = get_salary(self.gather.job, self.gather.grade, self.gather.year)
self.gather.salary = sal
print("升职成功！")
print(f"{self.gather.name},工号：{num},升职后职位{self.gather.job}{self.gather.grade}, 升职后薪资：{self.gather.salary}")
return
#-----------------------------------------------------------------------------------------------
def main():
m = Mange()
while True:
order = input("1.录入；2.查询；3.升职；4.降职；5.退出：")
if order == '5':
print("已退出。")
break
elif order == '1':
m.lu_ru()
elif order == '2':
m.cha_xu()
elif order == '3':
m.sheng_zhi()
main()
0
0.一个方法可以用在不同类型的数据上
1.可以让方法使用更加简洁
2.可以的
3.
4.降低耦合
5.不是
本帖最后由 阿伟同学 于 2023-3-8 09:32 编辑
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:
defis_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, self.job_state
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 :
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, self.job_state
r = self.jin_wei_qi(min_grade, max_grade, grade, c)
l = list(self.jobs.keys())
if r == -1:
if job != l:
self.jobs.remove(staff)
index = l.index(job) - 1
self.jobs].append(staff)
return l + str(self.job_state])
else:
return l + self.job_state]
elif r == 1:
if job != l[-1]:
self.jobs.remove(staff)
index = l.index(job) + 1
self.jobs].append(staff)
return l + str(self.job_state])
else:
return l[-1] + self.job_state]
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 = staff
self.jobs.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
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:
print(f"目前公司没有{self.job_state}！")
else:
print(f"目前{self.job_state}共有 {len(self.jobs)} 人:")
for each in self.jobs:
print(f"{each.uid} - {each.name}")
def upgrade(self):
uid = self.is_uid_exist()
if not uid:
print("该工号不存在！")
else:
staff = self.staffs
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
staff.grade = int(job)
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
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
staff.grade = int(job)
print("降级成功！")
print(f"{staff.name}, 工号：{staff.uid}, 升职后职位：{staff.job + str(staff.grade)}，当前薪资：{staff.salary()}({staff.salary() - salary:+})")
def main():
m = Manage()
m.manage()