0:见机行事
1：不同的对象执行不同的操作
2：是，一个是求和，一个是拼接
3：
4：
5：不是
#0
"对于不同的对象可以采用同一个方法、函数、运算符来体现多态"
#1
"简化代码增强可读性，实现对不同类型对象的适应使用"
#2
"可以"
#3
"当我看到 一只 像 鸭子 一样走路，像 鸭子 一样 游泳 ，像 鸭子 一样嘎嘎叫的 鸟 ，我就叫它 鸭子"
#4
"降低了耦合"
#5
"是"
#动动手
#0
card=9999
uid_dict={}
E_list,T_list,M_list=[],[],[]
job_dict={}
def main():
a=Member()
order=input("1.录入；2.查询；3.升级；4.降级；5.退出：")
while order!='5':
if order=="1":
a.rgi()
if order=="2":
a.search()
if order=="3":
a.up()
if order=="4":
a.down()
order=input("1.录入；2.查询；3.升级；4.降级；5.退出：")
class Member:
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 get_salary(self):#薪资
if self.job=="E":
self.salary=3000+500*self.grade+50*self.year
return self.salary
if self.job=="T":
self.salary=4000+800*self.grade+100*self.year
return self.salary
if self.job=="M":
self.salary=5000+1000*(self.grade+self.year)
return self.salary
#录入
def rgi(self):
global card#main中要有global card=9999
card+=1
self.uid=card
self.name=input("姓名:")
self.job=input("职位(E.普通员工；T.组长；M.经理):")
self.year=int(input("工龄:"))
self.grade=int(input("级别:"))
if self.job=="E" and self.grade>10:
self.grade=int(input("该职位最高级别为10，请重新录入级别:"))
if self.job=="T" and self.grade>6:
self.grade=int(input("该职位最高级别为6，请重新录入级别:"))
if self.job=="M" and self.grade>3:
self.grade=int(input("该职位最高级别为3，请重新录入级别:"))
self.salary=self.get_salary()
uid_dict=
E_list.extend()
T_list.extend()
M_list.extend()
job_dict["E"]=E_list
job_dict["T"]=T_list
job_dict["M"]=M_list
print(f"录入成功！姓名：{self.name},工号：{self.uid},薪资：{self.salary}")
#查询
def search(self):
order=input("1.员工查询；2.职位查询：")
if order=="1":
card=int(input("请输入工号："))
try:
uid_dict==None
except KeyError:
print("该工号不存在!")
else:
print(f"姓名：{uid_dict}\n职位：{uid_dict}\n级别：{uid_dict}\n工龄：{uid_dict}\n薪资：{uid_dict}\n")
if order=="2":
job=input("职位(E.普通员工；T.组长；M.经理):")
j_dict={"E":"普通员工","T":"组长","M":"经理"}
if len(job_dict)==0:
print(f"目前公司没有{j_dict}")
else:
print(f"目前{j_dict}共有{len(job_dict)}人")
]
#升级
def up(self):
uid=int(input("请输入工号："))
x=uid_dict
print(f"{x}，工号:{uid},当前职位：{x}{x},当前薪资：{x}")
uplevel=int(input("请输入需要增加的级数："))
joblevel={"E":10,"T":6,"M":3}
f=list(joblevel.keys())
if x+uplevel>joblevel]:
job_dict.remove(str(self.uid)+"-"+self.name)
x=f)+1]
x=1
self.job=x
self.grade=x
self.salary=self.get_salary()
x=self.salary
job_dict.append(str(self.uid)+"-"+self.name)
else:
x+=uplevel
self.grade=x
self.salary=self.get_salary()
x=self.salary
print("升级成功！")
print(f"{x}，工号:{uid},升级后职位：{x}{x},升级后薪资：{x}")
#降级
def down(self):
uid=int(input("请输入工号："))
x=uid_dict
print(f"{x}，工号:{uid},当前职位：{x}{x},当前薪资：{x}")
downlevel=int(input("请输入需要减少的级数："))
joblevel={"E":10,"T":6,"M":3}
f=list(joblevel.keys())
if x-downlevel<=0:
job_dict.remove(str(self.uid)+"-"+self.name)
x=f)-1]
x=joblevel]
self.job=x
self.grade=x
self.salary=self.get_salary()
x=self.salary
job_dict.append(str(self.uid)+"-"+self.name)
else:
x-=downlevel
self.grade=x
self.salary=self.get_salary()
x=self.salary
print("降级成功！")
print(f"{x}，工号:{uid},降级后职位：{x}{x},降级后薪资：{x}")
#class Employee(Member,RegistMixin):
{:5_90:}
{:5_90:}
{:5_90:}
0: show me
.
本帖最后由 Banky 于 2023-5-23 11:33 编辑
0
同一个运算符、函数或对象在不同的场景下，具有不同的作用效果
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 get_uid(self):
return self.uid
def get_name(self):
return self.name
def get_job(self):
return self.job
def get_grade(self):
return self.grade
def set_grade(self, grade):
self.grade = grade
def get_year(self):
return self.year
def salary(self):
return 3000 + 500 * self.grade + 100 * self.year
class Teamleader(Employee):
def salary(self):
return 6000 + 800 * self.grade + 200 * self.year
class Manager(Employee):
def salary(self):
return 10000 + 1000 * (self.grade + self.year)
def main():
mems = {}
jobs = {'E': [], 'T': [], 'M': []}
uid = 10000
MAX_E_GRADE = 10
MAX_T_GRADE = 6
MAX_M_GRADE = 3
while True:
ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
# 主线功能：录入
if ins == '1':
name = input("姓名：")
job = input("职位（E.普通员工;T.组长;M.经理）：")
year = int(input("工龄："))
grade = int(input("级别："))
if job == 'E':
while grade > MAX_E_GRADE:
grade = int(input(f"该职位最高级别为{MAX_E_GRADE}，请重新录入级别："))
e = Employee(name, job, grade, year, uid)
mems = e
jobs['E'].append(e)
if job == 'T':
while grade > MAX_T_GRADE:
grade = int(input(f"该职位最高级别为{MAX_T_GRADE}，请重新录入级别："))
e = Teamleader(name, job, grade, year, uid)
mems = e
jobs['T'].append(e)
if job == 'M':
while grade > MAX_M_GRADE:
grade = int(input(f"该职位最高级别为{MAX_M_GRADE}，请重新录入级别："))
e = Manager(name, job, grade, year, uid)
mems = e
jobs['M'].append(e)
print(f"录入成功！姓名：{name}，工号：{uid}，薪资：{e.salary()}")
uid += 1
# 主线功能：查询
if ins == '2':
op = input("1.员工查询;2.职位查询：")
# 支线功能：员工查询
if op == '1':
uid = int(input("请输入工号："))
if mems.get(uid):
e = mems
print(f"姓名：{e.get_name()}")
print(f"职位：{e.get_job()}")
print(f"级别：{e.get_grade()}")
print(f"工龄：{e.get_year()}")
print(f"薪资：{e.salary()}")
else:
print("该工号不存在！")
# 支线功能：职位查询
if op == '2':
job = input("职位（E.普通员工;T.组长;M.经理）：")
if job == 'E':
if jobs['E']:
print(f"目前普通员工共有 {len(jobs['E'])} 人：")
for each in jobs['E']:
print(f"{each.get_uid()} - {each.get_name()}")
else:
print("目前公司没有普通员工！")
if job == 'T':
if jobs['T']:
print(f"目前组长共有 {len(jobs['T'])} 人：")
for each in jobs['T']:
print(f"{each.get_uid()} - {each.get_name()}")
else:
print("目前公司没有组长！")
if job == 'M':
if jobs['M']:
print(f"目前经理共有 {len(jobs['M'])} 人：")
for each in jobs['M']:
print(f"{each.get_uid()} - {each.get_name()}")
else:
print("目前公司没有经理！")
# 主线功能：升级
if ins == '3':
uid = int(input("请输入工号："))
if mems.get(uid):
e = mems
print(f"{e.get_name()}，工号：{e.get_uid()}，当前职位：{e.get_job()}{e.get_grade()}，当前薪资：{e.salary()}")
name = e.get_name()
job = e.get_job()
grade = e.get_grade()
year = e.get_year()
old_salary = e.salary()
n = int(input("请输入需要增加的级数："))
if job == 'E':
if grade + n > MAX_E_GRADE:
# 如果发生职位变化，那么需要创建新的对象，并更新同步两个字典
job = 'T'
grade = 1
jobs['E'].remove(e)# 将jobs中相应职位的对象删除
e = Teamleader(name, job, grade, year, uid)# 生成新的对象
jobs['T'].append(e)# 添加到jobs中的新职位中
mems = e# mems也要相应的旧对象也要被覆盖
else:
e.set_grade(grade + n)
elif job == 'T':# 注意，这里要用elif，否则上面E变成T之后，还会在这里跑多一遍
if grade + n > MAX_T_GRADE:
job = 'M'
grade = 1
jobs['T'].remove(e)
e = Manager(name, job, grade, year, uid)
jobs['M'].append(e)
mems = e
else:
e.set_grade(grade + n)
elif job == 'M':# 注意，这里要用elif，否则上面T变成M之后，还会在这里跑多一遍
if grade + n > MAX_M_GRADE:
print("已达最高级别！")
grade = MAX_M_GRADE
else:
e.set_grade(grade + n)
new_salary = e.salary()
print("升级完毕！")
print(
f"{e.get_name()}，工号：{e.get_uid()}，升级后职位：{e.get_job()}{e.get_grade()}，升级后薪资：{e.salary()}(+{new_salary - old_salary})")
else:
print("该工号不存在！")
# 主线功能：降级
if ins == '4':
uid = int(input("请输入工号："))
if mems.get(uid):
e = mems
print(f"{e.get_name()}，工号：{e.get_uid()}，当前职位：{e.get_job()}{e.get_grade()}，当前薪资：{e.salary()}")
name = e.get_name()
job = e.get_job()
grade = e.get_grade()
year = e.get_year()
old_salary = e.salary()
n = int(input("请输入需要减少的级数："))
if job == 'M':
if grade - n <= 0:
job = 'T'
grade = MAX_T_GRADE
jobs['M'].remove(e)# 将jobs中相应职位的对象删除
e = Teamleader(name, job, grade, year, uid)# 生成新的对象
jobs['T'].append(e)# 添加到jobs中的新职位中
mems = e# mems也要相应的旧对象也要被覆盖
else:
e.set_grade(grade - n)
elif job == 'T':# 注意，这里要用elif，否则上面M变成T之后，还会在这里跑多一遍
if grade - n <= 0:
job = 'E'
grade = MAX_E_GRADE
jobs['T'].remove(e)
e = Employee(name, job, grade, year, uid)
jobs['E'].append(e)
mems = e
else:
e.set_grade(grade - n)
elif job == 'E':# 注意，这里要用elif，否则上面T变成E之后，还会在这里跑多一遍
if grade - n <= 0:
print("已达最低级别！")
grade = 1
new_salary = e.salary()
print("降级完毕！")
print(
f"{e.get_name()}，工号：{e.get_uid()}，降级后职位：{e.get_job()}{e.get_grade()}，降级后薪资：{e.salary()}({new_salary - old_salary})")
else:
print("该工号不存在！")
# 主线功能：退出
if ins == '5':
break
main()
0.重写
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 get_uid(self):
return self.uid
#获取姓名
def get_name(self):
return self.name
#获取职位
def get_job(self):
return self.job
#获取工龄
def get_year(self):
return self.year
#获取工资
def salary(self):
_salary=0
if self.job == "E":
_salary=3000+500*self.grade+50*self.year
elif self.job == "T":
_salary=4000+800*self.grade+100*self.year
elif self.job == "M":
_salary=5000+1000*(self.grade+self.year)
return _salary
#Manage类
class Manage:
def __init__(self):
self.E={}
self.T={}
self.M={}
self.id=10000
#显示菜单
def menu(self):
while True:
n=input("1.录入;2.查询;3.升级;4.降级;5.退出 :")
if n=="1":
self.enter()
elif n=="2":
self.search()
elif n=="3":
self.up_low_grade(1)
elif n=="4":
self.up_low_grade(2)
elif n=="5":
break
else:
print("没有此选项！")
#实现录入功能
def enter(self):
name=input("姓名：")
job=input("职位（E.普通员工;T.组长;M.经理）:").upper()
while True:
if job !="E" and job !="T" and job != "M":
job=input("输入错误，请重新输入：").upper()
else:
break
year=int(input("工龄："))
grade=int(input("级别："))
while True:
if job=="E":
if grade>10:
grade=int(input("该职位最高级别为10级，请重新录入级别："))
else:
break
elif job=="T":
if grade>6:
grade=int(input("该职位最高级别为6级，请重新录入级别："))
else:
break
elif job=="M":
if grade>3:
grade=int(input("该职位最高级别为3级，请重新录入级别："))
else:
break
employee=Employee(name,job,grade,year,self.id)
if job=="E":
self.E=employee
elif job=="T":
self.T=employee
elif job=="M":
self.M=employee
print(f"录入成功！姓名：{name}，工号：{self.id}，薪资：{employee.salary()}")
self.id+=1
#实现查询功能
def search(self):
n=int(input("1.员工查询;2.职位查询:"))
while True:
if n==1:
k={**self.E,**self.T,**self.M}
uid=int(input("请输入工号："))
if uid not in k:
print("该工号不存在！")
else:
print(f"姓名：{k.name}")
print(f"职位：{k.job}")
print(f"级别：{k.grade}")
print(f"工龄：{k.year}")
print(f"薪资：{k.salary()}")
break
elif n==2:
j=input("职位（E.普通员工;T.组长;M.经理）:").upper()
if j=="E":
if len(self.E)==0:
print("目前公司没有普通员工！")
else:
print(f"目前普通员工有{len(self.E)}人")
for k,v in self.E.items():
print(f"{k} - {v.name}")
elif j=="T":
if len(self.T)==0:
print("目前公司没有组长！")
else:
print(f"目前普通员工有{len(self.T)}人")
for k,v in self.T.items():
print(f"{k} - {v.name}")
elif j=="M":
iflen(self.M)==0:
print("目前公司没有经理！")
else:
print(f"目前普通员工有{len(self.M)}人")
for k,v in self.M.items():
print(f"{k} - {v.name}")
break
else:
n=int(input("请重新输入："))
#实现升降级功能
def up_low_grade(self,n):
if n==1:
uid=int(input("请输入工号："))
k={**self.E,**self.T,**self.M}
if uid not in k:
print("未查询到工号！")
elif uid in self.E:
print(f"{self.E.name},工号:{uid},当前职位:{self.E.job}{self.E.grade},当前薪资：{self.E.salary()}")
salary=self.E.salary()
g=int(input("请输入需要增加的级数："))
if 10<self.E.grade+g:
self.T=self.E
self.E.pop(uid)
self.T.job="T"
self.T.grade=1
print("升级成功！")
print(f"{self.T.name},工号:{uid},当前职位:{self.T.job}{self.T.grade},升级后薪资:{self.T.salary()}(+{self.T.salary()-salary})")
else:
self.E.grade+=g
print("升级成功！")
print(f"{self.E.name},工号:{uid},当前职位:{self.E.job}{self.E.grade},升级后薪资:{self.E.salary()}(+{self.E.salary()-salary})")
elif uid in self.T:
print(f"{self.T.name},工号:{uid},当前职位:{self.T.job}{self.T.grade},当前薪资:{self.T.salary()}")
salary=self.T.salary()
g=int(input("请输入需要增加的级数："))
if 6<self.T.grade+g:
self.M=self.T
self.T.pop(uid)
self.M.job="M"
self.M.grade=1
print("升级成功！")
print(f"{self.M.name},工号:{uid},当前职位:{self.M.job}{self.M.grade},升级后薪资:{self.M.salary()}(+{self.M.salary()-salary})")
else:
self.E.grade+=g
print("升级成功！")
print(f"{self.T.name},工号:{uid},当前职位:{self.T.job}{self.T.grade},升级后薪资:{self.T.salary()}(+{self.T.salary()-salary})")
elif uid in self.M:
if self.M.grade+g<3:
self.M.grade+=g
print("升级成功！")
print(f"{self.M.name},工号:{uid},当前职位:{self.M.job}{self.M.grade},升级后薪资:{self.M.salary()}(+{self.M.salary()-salary})")
else:
print("级数升太多！")
elif n==2:
uid=int(input("请输入工号："))
k={**self.E,**self.T,**self.M}
if uid not in k:
print("未查询到工号！")
elif uid in self.E:
print(f"{self.E.name},工号:{uid},当前职位:{self.E.job}{self.E.grade},当前薪资:{self.E.salary()}")
salary=self.E.salary()
g=int(input("请输入需要减少的级数："))
if self.E.grade-g>0:
self.E.grade-=g
print("降级成功！")
print(f"{self.E.name},工号:{uid},当前职位:{self.E.job}{self.E.grade},降级后薪资:{self.E.salary()}(-{salary-self.E.salary()})")
else:
print("级数降太多！")
elif uid in self.T:
print(f"{self.T.name},工号:{uid},当前职位:{self.T.job}{self.T.grade},当前薪资:{self.T.salary()}")
salary=self.T.salary()
g=int(input("请输入需要减少的级数："))
if self.T.grade-g>0:
self.T.grade-=g
print("降级成功！")
print(f"{self.T.name},工号:{uid}，当前职位：{self.T.job}{self.T.grade}，降级后薪资：{self.T.salary()}(-{salary-self.T.salary()})")
else:
self.E=self.T
self.T.pop(uid)
self.E.job="E"
self.E.grade=10
print("降级成功！")
print(f"{self.E.name},工号:{uid},当前职位:{self.E.job}{self.E.grade},降级后薪资:{self.E.salary()}(-{salary-self.E.salary()})")
elif uid in self.M:
print(f"{self.M.name},工号:{uid},当前职位:{self.M.job}{self.M.grade},当前薪资:{self.M.salary()}")
salary=self.M.salary()
g=int(input("请输入需要减少的级数："))
if self.M.grade-g>0:
self.M.grade-=g
print("降级成功！")
print(f"{self.M.name},工号:{uid},当前职位:{self.M.job}{self.M.grade},降级后薪资:{self.M.salary()}(-{salary-self.M.salary()})")
else:
self.T=self.M
self.M.pop(uid)
self.T.job="T"
self.T.grade=6
print("降级成功！")
print(f"{self.T.name},工号:{uid},当前职位：{self.T.job}{self.T.grade},降级后薪资:{self.T.salary()}(-{salary-self.T.salary()})")
def main():
m=Manage()
m.menu()
class Worker:
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):
if self.job == "E":
return 3000 + 500 * int(self.grade) + 50 * int(self.year)
elif self.job == "T":
return 4000 + 800 * int(self.grade) + 100 * int(self.year)
elif self.job == "M":
return 5000 + 1000 * (int(self.grade) + int(self.year))
class Employee(Worker):
def __init__(self, name, job, grade, year, uid):
super().__init__(name, job, grade, year, uid)
class Teamleader(Worker):
def __init__(self, name, job, grade, year, uid):
super().__init__(name, job, grade, year, uid)
class Manager(Worker):
def __init__(self, name, job, grade, year, uid):
super().__init__(name, job, grade, year, uid)
class Program:
uid = 10000
uid_list = {}# uid:iterable
employee_list = {"E":[], "T":[], "M":[]}# 对录入的员工分类存放
def register(self):
name = input("姓名：")
job = input("职位（E.普通员工；T.组长；M.经理）：")
year = input("工龄：")
grade = input("级别：")
# 根据职位对级别进行限制
if job == "E" and int(grade) > 10:
grade = input("该职位最高级别为10，请重新录入级别：")
elif job == "T" and int(grade) > 6:
grade = input("该职位最高级别为6，请重新录入级别：")
elif job == "M" and int(grade) > 3:
grade = input("该职位最高级别为3，请重新录入级别：")
man = Employee(name, job, grade, year, self.uid)
self.uid_list = man
self.employee_list.append(man)
print("录入成功！姓名：{}，工号：{}，薪资：{}".format(man.name, man.uid, man.salary()))
self.uid += 1
def query(self):
command = input("1.员工查询；2.职位查询：")
if command == "1":
# 员工查询
uid = int(input("请输入工号："))
if self.uid_list.get(uid, False):# 判断输入的工号是否存在
uid_worker = self.uid_list
print("姓名：{}\n职位：{}\n级别：{}\n工龄：{}\n薪资：{}\n".format(
uid_worker.get_name(),
uid_worker.get_job(),
uid_worker.get_grade(),
uid_worker.get_year(),
uid_worker.salary()))
else:# 工号不存在时打印提示
print("该工号不存在！")
elif command == "2":
# 职位查询
job = input("职位（E.普通员工；T.组长；M.经理）：")
if len(self.employee_list):
# 有该职位的员工
if job == "E":
print("目前普通员工共有 {} 人：".format(len(self.employee_list)))
elif job == "T":
print("目前组长共有 {} 人：".format(len(self.employee_list)))
elif job == "M":
print("目前经理共有 {} 人：".format(len(self.employee_list)))
for each in self.employee_list:
print("{} - {}".format(each.get_uid(), each.get_name()))
print()
else:
# 没有该职位的员工
print("该公司目前没有{}".format(job))
def level_up(self):
uid = int(input("请输入工号："))
uid_worker = self.uid_list
b_salary = uid_worker.salary()
print("{}，工号：{}当前职位：{}，当前薪资：{}".format(uid_worker.get_name(), uid_worker.get_uid(), uid_worker.get_job()+uid_worker.get_grade(), b_salary))
up_level = int(input("请输入需要增加的级数："))
uid_worker.job, uid_worker.grade = self.if_grade(uid_worker.get_job(), int(uid_worker.get_grade()), up_level)
print("升级成功！")
print("{}，工号：{}当前职位：{}，升级后薪资：{}(+{})".format(uid_worker.get_name(), uid_worker.get_uid(), uid_worker.get_job()+uid_worker.get_grade(), uid_worker.salary(), uid_worker.salary()-b_salary))
def level_down(self):
uid = int(input("请输入工号："))
uid_worker = self.uid_list
b_salary = uid_worker.salary()
print("{}，工号：{}当前职位：{}，当前薪资：{}".format(uid_worker.get_name(), uid_worker.get_uid(), uid_worker.get_job()+uid_worker.get_grade(), b_salary))
down_level = -int(input("请输入需要降低的级数："))
uid_worker.job, uid_worker.grade = self.if_grade(uid_worker.get_job(), int(uid_worker.get_grade()), down_level)
print("降级成功！")
print("{}，工号：{}当前职位：{}，降级后薪资：{}({})".format(uid_worker.get_name(), uid_worker.get_uid(), uid_worker.get_job()+uid_worker.get_grade(), uid_worker.salary(), uid_worker.salary()-b_salary))
def if_grade(self, job:str, grade:int, down:int)->tuple:
if job == "E":
if grade + down > 10:
return "T", "1"
elif grade + down <= 0:
return "E", "1"
else:
return "E", str(grade + down)
elif job == "T":
if grade + down > 6:
return "M", "1"
elif grade + down <= 0:
return "T", "10"
else:
return "T", str(grade + down)
elif job == "M":
if grade + down > 3:
return "M", "3"
elif grade + down <= 0:
return "T", "6"
else:
return "M", str(grade + down)
def system(self):
while True:
command = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
if command == "1":
self.register()
elif command == "2":
self.query()
elif command == "3":
self.level_up()
elif command == "4":
self.level_down()
elif command == "5":
break
p = Program()
p.system()
0.继承
1.将不同类型对象以相同方法实现
2.可以
3.双兔傍地走，安能辨我是雄雌
4.降低了耦合
5.不算吧
0.
1
1
2023.5.13
第27天 加油加油加油~
7
问答题：
0、
1、
2、是的
3、
4、降低了耦合度
5、不是
动动手：
0、
class Member:
def __init__(self, name, job, grade, year, salary):
self.name = name
self.job = job
self.grade = grade
self.year = year
self.salary = salary
class Company:
def __init__(self):
self.userid = 10000
self.infoE = {}
self.infoT = {}
self.infoM = {}
def main(self):
while True:
num = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
if num == "5":
break
elif num == "1":
self.enter()
elif num == "2":
self.research()
elif num == "3":
self.increase()
# else:
# self.decrease()
def salary(self, job, grade, year):
if job == "E":
salary = 3000 + 500 * grade + 50 * year
elif job == "T":
salary = 4000 + 800 * grade + 100 * year
else:
salary = 5000 + 1000 * ( grade + year )
return salary
def enter(self):
name = input("姓名：")
job = input("职位（E.普通员工；T.组长；M.经理）：")
year = int(input("工龄："))
grade = int(input("级别："))
if job == "E":
while True:
if grade > 10:
grade = int(input("该职位最高级别为10，请重新录入级别："))
else:
break
uid = self.userid
self.userid += 1
salary = self.salary(job, grade, year)
self.infoE = Member(name, job, grade, year, salary)
elif job == "T":
while True:
if grade > 6:
grade = int(input("该职位最高级别为6，请重新录入级别："))
else:
break
uid = self.userid
self.userid += 1
salary = self.salary(job, grade, year)
self.infoT = Member(name, job, grade, year, salary)
else:
while True:
if grade > 3:
grade = int(input("该职位最高级别为3，请重新录入级别："))
else:
break
uid = self.userid
self.userid += 1
salary = self.salary(job, grade, year)
self.infoM = Member(name, job, grade, year, salary)
print("录入成功！姓名：", name, "工号：", uid, "薪资：", salary)
def research(self):
num = input("1.员工查询；2.职位查询：")
if num == "1":
uid = int(input("请输入工号："))
if uid in self.infoE:
print("姓名：", self.infoE.name)
print("职位：", self.infoE.job)
print("级别：", self.infoE.grade)
print("工龄：", self.infoE.year)
print("薪资：", self.infoE.salary)
elif uid in self.infoT:
print("姓名：", self.infoT.name)
print("职位：", self.infoT.job)
print("级别：", self.infoT.grade)
print("工龄：", self.infoT.year)
print("薪资：", self.infoT.salary)
elif uid in self.infoM:
print("姓名：", self.infoM.name)
print("职位：", self.infoM.job)
print("级别：", self.infoM.grade)
print("工龄：", self.infoM.year)
print("薪资：", self.infoM.salary)
else:
print("该工号不存在!")
else:
job = input("职位（E.普通员工；T.组长；M.经理）：")
if job == "E":
print("目前普通员工有", len(self.infoE), "人：")
for key, value in self.infoE.items():
print(key, "-", value.name)
def increase(self):
uid = int(input("请输入工号："))
if uid in self.infoE:
print(self.infoE.name, "工号：", uid, "当前职位：", self.infoE.job, self.infoE.grade,
"当前薪资：", self.infoE.salary)
inc = int(input("请输入需要增加的级数："))
if inc + self.infoE.grade > 10:
self.infoE.job = "T"
self.infoE.grade = 1
else:
self.infoE.grade += inc
elif uid in self.infoM:
print(self.infoM.name, "工号：", uid, "当前职位：", self.infoM.job, self.infoM.grade,
"当前薪资：", self.infoM.salary)
inc = int(input("请输入需要增加的级数："))
if inc + self.infoT.grade > 6:
self.infoT.job = "M"
self.infoT.grade = 1
else:
self.infoT.grade += inc
else:
print(self.infoT.name, "工号：", uid,"当前职位：", self.infoT.job, self.infoT.grade,
"当前薪资：", self.infoT.salary)
inc = int(input("请输入需要增加的级数："))
if inc + self.infoM.grade > 3:
print("已超过最高级别")
else:
self.infoM.grade += inc
# def decrease(self):
c = Company()
c.main()
0.继承重新
1.对不同的对象做处不同处理,耦合性比较好
2.可以,运算符 +的多态表现
3.看起来像鸭子,跑起来鸭子,叫起来像鸭子那么,就认为他是鸭子
4.降低耦合
5.是
123