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

小白00001

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

0:见机行事
1：不同的对象执行不同的操作
2：是，一个是求和，一个是拼接
3：
4：
5：不是

liang_xy

有其月

#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[self.uid]=[self.name,self.job,self.grade,self.year, self.salary]
        E_list.extend([str(self.uid)+"-"+self.name for x in self.job if self.job=='E'])
        T_list.extend([str(self.uid)+"-"+self.name for x in self.job if self.job=="T"])
        M_list.extend([str(self.uid)+"-"+self.name for x in self.job if self.job=="M"])
        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[card]==None
            except KeyError:
                print("该工号不存在!")
            else:
                print(f"姓名：{uid_dict[card][0]}\n职位：{uid_dict[card][1]}\n级别：{uid_dict[card][2]}\n工龄：{uid_dict[card][3]}\n薪资：{uid_dict[card][4]}\n")
        if order=="2":
            job=input("职位(E.普通员工；T.组长；M.经理):")
            j_dict={"E":"普通员工","T":"组长","M":"经理"}
            if len(job_dict[job])==0:
                print(f"目前公司没有{j_dict[job]}")
            else:
                print(f"目前{j_dict[job]}共有{len(job_dict[job])}人")
                [print(x) for x in job_dict[job]]
#升级
    def up(self):
        uid=int(input("请输入工号："))
        x=uid_dict[uid]
        print(f"{x[0]}，工号:{uid},当前职位：{x[1]}{x[2]},当前薪资：{x[4]}")
        uplevel=int(input("请输入需要增加的级数："))
        joblevel={"E":10,"T":6,"M":3}
        f=list(joblevel.keys())
        if x[2]+uplevel>joblevel[x[1]]:
            job_dict[self.job].remove(str(self.uid)+"-"+self.name)
            x[1]=f[f.index(x[1])+1]
            x[2]=1
            self.job=x[1]
            self.grade=x[2]
            self.salary=self.get_salary()
            x[4]=self.salary
            job_dict[self.job].append(str(self.uid)+"-"+self.name)
        else:
            x[2]+=uplevel
            self.grade=x[2]
            self.salary=self.get_salary()
            x[4]=self.salary
        print("升级成功！")
        print(f"{x[0]}，工号:{uid},升级后职位：{x[1]}{x[2]},升级后薪资：{x[4]}")
#降级
    def down(self):
        uid=int(input("请输入工号："))
        x=uid_dict[uid]
        print(f"{x[0]}，工号:{uid},当前职位：{x[1]}{x[2]},当前薪资：{x[4]}")
        downlevel=int(input("请输入需要减少的级数："))
        joblevel={"E":10,"T":6,"M":3}
        f=list(joblevel.keys())
        if x[2]-downlevel<=0:
            job_dict[self.job].remove(str(self.uid)+"-"+self.name)
            x[1]=f[f.index(x[1])-1]
            x[2]=joblevel[x[1]]
            self.job=x[1]
            self.grade=x[2]
            self.salary=self.get_salary()
            x[4]=self.salary
            job_dict[self.job].append(str(self.uid)+"-"+self.name)
        else:
            x[2]-=downlevel
            self.grade=x[2]
            self.salary=self.get_salary()
            x[4]=self.salary
        print("降级成功！")
        print(f"{x[0]}，工号:{uid},降级后职位：{x[1]}{x[2]},降级后薪资：{x[4]}")
    #class Employee(Member,RegistMixin):

   
   

暮雨朝云

暮雨朝云

暮雨朝云

D小二

0: show me

李明海

.

Banky

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[uid] = 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[uid] = 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[uid] = 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[uid]
                    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[uid]
                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[uid] = 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[uid] = 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[uid]
                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[uid] = 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[uid] = 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()

fishC121381

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[self.id]=employee
        elif job=="T":
            self.T[self.id]=employee
        elif job=="M":
            self.M[self.id]=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[uid].name}")
                    print(f"职位：{k[uid].job}")
                    print(f"级别：{k[uid].grade}")
                    print(f"工龄：{k[uid].year}")
                    print(f"薪资：{k[uid].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":
                    if  len(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[uid].name},工号:{uid},当前职位:{self.E[uid].job}{self.E[uid].grade},当前薪资：{self.E[uid].salary()}")
                salary=self.E[uid].salary()
                g=int(input("请输入需要增加的级数："))
                if 10<self.E[uid].grade+g:
                    self.T[uid]=self.E[uid]
                    self.E.pop(uid)
                    self.T[uid].job="T"
                    self.T[uid].grade=1
                    print("升级成功！")
                    print(f"{self.T[uid].name},工号:{uid},当前职位:{self.T[uid].job}{self.T[uid].grade},升级后薪资:{self.T[uid].salary()}(+{self.T.salary()-salary})")
                else:
                    self.E[uid].grade+=g
                    print("升级成功！")
                    print(f"{self.E[uid].name},工号:{uid},当前职位:{self.E[uid].job}{self.E[uid].grade},升级后薪资:{self.E[uid].salary()}(+{self.E.salary()-salary})")
            elif uid in self.T:
                print(f"{self.T[uid].name},工号:{uid},当前职位:{self.T[uid].job}{self.T[uid].grade},当前薪资:{self.T[uid].salary()}")
                salary=self.T[uid].salary()
                g=int(input("请输入需要增加的级数："))
                if 6<self.T[uid].grade+g:
                    self.M[uid]=self.T[uid]
                    self.T.pop(uid)
                    self.M[uid].job="M"
                    self.M[uid].grade=1
                    print("升级成功！")
                    print(f"{self.M[uid].name},工号:{uid},当前职位:{self.M[uid].job}{self.M[uid].grade},升级后薪资:{self.M[uid].salary()}(+{self.M[uid].salary()-salary})")
                else:
                    self.E[uid].grade+=g
                    print("升级成功！")
                    print(f"{self.T[uid].name},工号:{uid},当前职位:{self.T[uid].job}{self.T[uid].grade},升级后薪资:{self.T[uid].salary()}(+{self.T[uid].salary()-salary})")
            elif uid in self.M:
                if self.M[uid].grade+g<3:
                    self.M[uid].grade+=g
                    print("升级成功！")
                    print(f"{self.M[uid].name},工号:{uid},当前职位:{self.M[uid].job}{self.M[uid].grade},升级后薪资:{self.M[uid].salary()}(+{self.M[uid].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[uid].name},工号:{uid},当前职位:{self.E[uid].job}{self.E[uid].grade},当前薪资:{self.E[uid].salary()}")
                salary=self.E[uid].salary()
                g=int(input("请输入需要减少的级数："))
                if self.E[uid].grade-g>0:
                    self.E[uid].grade-=g
                    print("降级成功！")
                    print(f"{self.E[uid].name},工号:{uid},当前职位:{self.E[uid].job}{self.E[uid].grade},降级后薪资:{self.E[uid].salary()}(-{salary-self.E[uid].salary()})")
                else:
                    print("级数降太多！")
            elif uid in self.T:
                print(f"{self.T[uid].name},工号:{uid},当前职位:{self.T[uid].job}{self.T[uid].grade},当前薪资:{self.T[uid].salary()}")
                salary=self.T[uid].salary()
                g=int(input("请输入需要减少的级数："))
                if self.T[uid].grade-g>0:
                    self.T[uid].grade-=g
                    print("降级成功！")
                    print(f"{self.T[uid].name},工号:{uid}，当前职位：{self.T[uid].job}{self.T[uid].grade}，降级后薪资：{self.T[uid].salary()}(-{salary-self.T[uid].salary()})")
                else:
                    self.E[uid]=self.T[uid]
                    self.T.pop(uid)
                    self.E[uid].job="E"
                    self.E[uid].grade=10
                    print("降级成功！")
                    print(f"{self.E[uid].name},工号:{uid},当前职位:{self.E[uid].job}{self.E[uid].grade},降级后薪资:{self.E[uid].salary()}(-{salary-self.E[uid].salary()})")
            elif uid in self.M:
                print(f"{self.M[uid].name},工号:{uid},当前职位:{self.M[uid].job}{self.M[uid].grade},当前薪资:{self.M[uid].salary()}")
                salary=self.M[uid].salary()
                g=int(input("请输入需要减少的级数："))
                if self.M[uid].grade-g>0:
                    self.M[uid].grade-=g
                    print("降级成功！")
                    print(f"{self.M[uid].name},工号:{uid},当前职位:{self.M[uid].job}{self.M[uid].grade},降级后薪资:{self.M[uid].salary()}(-{salary-self.M[uid].salary()})")
                else:
                    self.T[uid]=self.M[uid]
                    self.M.pop(uid)
                    self.T[uid].job="T"
                    self.T[uid].grade=6
                    print("降级成功！")
                    print(f"{self.T[uid].name},工号:{uid},当前职位：{self.T[uid].job}{self.T[uid].grade},降级后薪资:{self.T[uid].salary()}(-{salary-self.T[uid].salary()})")
                    
def main():
    m=Manage()
    m.menu()

学医救不了蒙德

1. class Worker:
   
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.     def get_uid(self):
   
9.         return self.uid
   
10.     def get_name(self):
    
11.         return self.name
    
12.     def get_job(self):
    
13.         return self.job
    
14.     def get_grade(self):
    
15.         return self.grade
    
16.     def get_year(self):
    
17.         return self.year
    
18.     def salary(self):
    
19.         if self.job == "E":
    
20.             return 3000 + 500 * int(self.grade) + 50 * int(self.year)
    
21.         elif self.job == "T":
    
22.             return 4000 + 800 * int(self.grade) + 100 * int(self.year)
    
23.         elif self.job == "M":
    
24.             return 5000 + 1000 * (int(self.grade) + int(self.year))
    
25. 
    
26. class Employee(Worker):
    
27.     def __init__(self, name, job, grade, year, uid):
    
28.         super().__init__(name, job, grade, year, uid)
    
29. 
    
30. class Teamleader(Worker):
    
31.     def __init__(self, name, job, grade, year, uid):
    
32.         super().__init__(name, job, grade, year, uid)
    
33. 
    
34. class Manager(Worker):
    
35.     def __init__(self, name, job, grade, year, uid):
    
36.         super().__init__(name, job, grade, year, uid)
    
37. 
    
38. class Program:
    
39.     uid = 10000
    
40.     uid_list = {}# uid:iterable
    
41.     employee_list = {"E":[], "T":[], "M":[]}# 对录入的员工分类存放
    
42.     def register(self):
    
43.         name = input("姓名：")
    
44.         job = input("职位（E.普通员工；T.组长；M.经理）：")
    
45.         year = input("工龄：")
    
46.         grade = input("级别：")
    
47.         # 根据职位对级别进行限制
    
48.         if job == "E" and int(grade) > 10:
    
49.             grade = input("该职位最高级别为10，请重新录入级别：")
    
50.         elif job == "T" and int(grade) > 6:
    
51.             grade = input("该职位最高级别为6，请重新录入级别：")
    
52.         elif job == "M" and int(grade) > 3:
    
53.             grade = input("该职位最高级别为3，请重新录入级别：")
    
54.         man = Employee(name, job, grade, year, self.uid)
    
55.         self.uid_list[self.uid] = man
    
56.         self.employee_list[job].append(man)
    
57.         print("录入成功！姓名：{}，工号：{}，薪资：{}".format(man.name, man.uid, man.salary()))
    
58.         self.uid += 1
    
59. 
    
60.     def query(self):
    
61.         command = input("1.员工查询；2.职位查询：")
    
62.         if command == "1":
    
63.             # 员工查询
    
64.             uid = int(input("请输入工号："))
    
65.             if self.uid_list.get(uid, False):# 判断输入的工号是否存在
    
66.                 uid_worker = self.uid_list[uid]
    
67.                 print("姓名：{}\n职位：{}\n级别：{}\n工龄：{}\n薪资：{}\n".format(
    
68.                     uid_worker.get_name(),
    
69.                     uid_worker.get_job(),
    
70.                     uid_worker.get_grade(),
    
71.                     uid_worker.get_year(),
    
72.                     uid_worker.salary()))
    
73.             else:# 工号不存在时打印提示
    
74.                 print("该工号不存在！")
    
75.         elif command == "2":
    
76.             # 职位查询
    
77.             job = input("职位（E.普通员工；T.组长；M.经理）：")
    
78.             if len(self.employee_list[job]):
    
79.                 # 有该职位的员工
    
80.                 if job == "E":
    
81.                     print("目前普通员工共有 {} 人：".format(len(self.employee_list[job])))
    
82.                 elif job == "T":
    
83.                     print("目前组长共有 {} 人：".format(len(self.employee_list[job])))
    
84.                 elif job == "M":
    
85.                     print("目前经理共有 {} 人：".format(len(self.employee_list[job])))
    
86.                 for each in self.employee_list[job]:
    
87.                     print("{} - {}".format(each.get_uid(), each.get_name()))
    
88.                 print()
    
89.             else:
    
90.                 # 没有该职位的员工
    
91.                 print("该公司目前没有{}".format(job))
    
92. 
    
93.     def level_up(self):
    
94.         uid = int(input("请输入工号："))
    
95.         uid_worker = self.uid_list[uid]
    
96.         b_salary = uid_worker.salary()
    
97.         print("{}，工号：{}当前职位：{}，当前薪资：{}".format(uid_worker.get_name(), uid_worker.get_uid(), uid_worker.get_job()+uid_worker.get_grade(), b_salary))
    
98.         up_level = int(input("请输入需要增加的级数："))
    
99.         uid_worker.job, uid_worker.grade = self.if_grade(uid_worker.get_job(), int(uid_worker.get_grade()), up_level)
    
100.         print("升级成功！")
     
101.         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))
     
102. 
     
103.     def level_down(self):
     
104.         uid = int(input("请输入工号："))
     
105.         uid_worker = self.uid_list[uid]
     
106.         b_salary = uid_worker.salary()
     
107.         print("{}，工号：{}当前职位：{}，当前薪资：{}".format(uid_worker.get_name(), uid_worker.get_uid(), uid_worker.get_job()+uid_worker.get_grade(), b_salary))
     
108.         down_level = -int(input("请输入需要降低的级数："))
     
109.         uid_worker.job, uid_worker.grade = self.if_grade(uid_worker.get_job(), int(uid_worker.get_grade()), down_level)
     
110.         print("降级成功！")
     
111.         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))
     
112. 
     
113.     def if_grade(self, job:str, grade:int, down:int)->tuple:
     
114.         if job == "E":
     
115.             if grade + down > 10:
     
116.                 return "T", "1"
     
117.             elif grade + down <= 0:
     
118.                 return "E", "1"
     
119.             else:
     
120.                 return "E", str(grade + down)
     
121.         elif job == "T":
     
122.             if grade + down > 6:
     
123.                 return "M", "1"
     
124.             elif grade + down <= 0:
     
125.                 return "T", "10"
     
126.             else:
     
127.                 return "T", str(grade + down)
     
128.         elif job == "M":
     
129.             if grade + down > 3:
     
130.                 return "M", "3"
     
131.             elif grade + down <= 0:
     
132.                 return "T", "6"
     
133.             else:
     
134.                 return "M", str(grade + down)
     
135. 
     
136.     def system(self):
     
137.         while True:
     
138.                 command = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
     
139.                 if command == "1":
     
140.                     self.register()
     
141.                 elif command == "2":
     
142.                     self.query()
     
143.                 elif command == "3":
     
144.                     self.level_up()
     
145.                 elif command == "4":
     
146.                     self.level_down()
     
147.                 elif command == "5":
     
148.                     break
     
149. 
     
150. p = Program()
     
151. p.system()

复制代码

siryang

0.继承
1.将不同类型对象以相同方法实现
2.可以
3.双兔傍地走，安能辨我是雄雌
4.降低了耦合
5.不算吧

0.

wakin

1

dqx1223

1

orangehyh

2023.5.13

RainaWin

第27天 加油加油加油~

hi我欲成仙

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[uid] = 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[uid] = 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[uid] = 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[uid].name)
                print("职位：", self.infoE[uid].job)
                print("级别：", self.infoE[uid].grade)
                print("工龄：", self.infoE[uid].year)
                print("薪资：", self.infoE[uid].salary)
            elif uid in self.infoT:
                print("姓名：", self.infoT[uid].name)
                print("职位：", self.infoT[uid].job)
                print("级别：", self.infoT[uid].grade)
                print("工龄：", self.infoT[uid].year)
                print("薪资：", self.infoT[uid].salary)
            elif uid in self.infoM:
                print("姓名：", self.infoM[uid].name)
                print("职位：", self.infoM[uid].job)
                print("级别：", self.infoM[uid].grade)
                print("工龄：", self.infoM[uid].year)
                print("薪资：", self.infoM[uid].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[uid].name, "工号：", uid, "当前职位：", self.infoE[uid].job, self.infoE[uid].grade,
                  "当前薪资：", self.infoE[uid].salary)
            inc = int(input("请输入需要增加的级数："))
            if inc + self.infoE[uid].grade > 10:
                self.infoE[uid].job = "T"
                self.infoE[uid].grade = 1
            else:
                self.infoE[uid].grade += inc
        elif uid in self.infoM:
            print(self.infoM[uid].name, "工号：", uid, "当前职位：", self.infoM[uid].job, self.infoM[uid].grade,
                  "当前薪资：", self.infoM[uid].salary)
            inc = int(input("请输入需要增加的级数："))
            if inc + self.infoT[uid].grade > 6:
                self.infoT[uid].job = "M"
                self.infoT[uid].grade = 1
            else:
                self.infoT[uid].grade += inc
        else:
            print(self.infoT[uid].name, "工号：", uid,"当前职位：", self.infoT[uid].job, self.infoT[uid].grade,
                  "当前薪资：", self.infoT[uid].salary)
            inc = int(input("请输入需要增加的级数："))
            if inc + self.infoM[uid].grade > 3:
                print("已超过最高级别")
            else:
                self.infoM[uid].grade += inc


    # def decrease(self):


c = Company()
c.main()

温客行

0.继承重新
1.对不同的对象做处不同处理,耦合性比较好
2.可以,运算符 +的多态表现
3.看起来像鸭子,跑起来鸭子,叫起来像鸭子那么,就认为他是鸭子
4.降低耦合
5.是

colorfly

123