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

李明海

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

.

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

原野之风

1

greetland

学习

AZ5323

1

tengke

1

snowflyw

1.根据不同的对象采取不同的操作
2.属于多态
4.降低了耦合度
5.不属于多态

hcm666

# 0. 请按要求编写一个企业员工管理程序。
# 需要实现的要求：

class EmployeeM:
# b. 员工属性：姓名（name）、职位（job）、级别（grade）、工龄（year）、工号（uid）
    name =None
    job = None
    grade = None
    year = None
    uid =None
# a. 员工分类：普通员工（Employee）、组长（Teamleader）、经理（Manager）
# c. 员工方法：
# get_uid() -- 获取工号
    def set_uid(self,uid):
         self.uid=uid
    def get_uid(self):
        return  self.uid
# get_name() -- 获取姓名
    def set_name(self,name):
         self.name=name
    def get_name(self):
        return self.name
# get_job() -- 获取职位
    def set_job(self,job):
        dif = {'E': 'Employee', 'T': 'Teamleader', 'M': 'Manager'}
        self.job=job
    def get_job(self):
        return self.job
# get_grade() -- 获取级别
    def set_grade(self,grade):
            self.grade=grade
    def get_grade(self):
        return self.grade
# get_year() -- 获取工龄
    def set_year(self,year):
         self.year=year
    def get_year(self):
        return self.year
# salary() -- 统计并返回工资（计算方法如下）
# d. 员工工资计算方法：
# 普通员工：3000 + 500 * 级别 + 50 * 工龄
# 组长：4000 + 800 * 级别 + 100 * 工龄
# 经理：5000 + 1000 * (级别 + 工龄)
    def salary(self):
        if self.grade==1:
            self.salarysum=3000 + 500 * int(self.grade) + 50 * int(self.year)
        elif self.grade==2:
            self.salarysum = 4000 + 800 * int(self.grade) + 100 * int(self.year)
        else:
            self.salarysum = 5000 + 1000 * (int(self.grade) + int(self.year))
        return self.salarysum
# e. 程序功能：
class Manager:

    def __init__(self):
        self.em = EmployeeM()
        self.idstart = 10000
        self.eee={}
# 录入员工数据功能（工号自动分配，由 10000 开始）
    def inEmployee(self):
        name = 'hcm'
        self.em.set_name(name)
        job = 'M'
        self.em.set_job(job)
        grade = '7'
        self.em.set_grade(grade)
        year = '15'
        self.em.set_year(year)
        uid = self.idstart+1
        while uid in self.eee:
            uid = uid +1
        self.em.set_uid(uid)
        self.salarys = self.em.salary()
        self.eee[self.em.get_uid()]=[self.em.get_name(),
                                     self.em.get_job(),
                                     self.em.get_grade(),
                                     self.em.get_year(),
                                     self.salarys]

        print(f'录入成功 name:{self.eee[self.em.get_uid()][0]} '
              f'职称:{str(self.eee[self.em.get_uid()][1])+str(self.eee[self.em.get_uid()][2])}'
              f'工资:{self.salarys}')

        print('inEmployee',self.eee)
# 查询功能，分为员工查询和职位查询（见程序实现截图）
    def checkEmployee(self):
        print('checkEmployee',self.eee)
        # self.uid =input('请输入UID')
        self.uid = '10001'
        print(int(self.uid) in self.eee)
        if int(self.uid) in self.eee:
            print(f'查询成功！ name:{self.eee[self.em.get_uid()][0]} '
                  f'职称:{str(self.eee[self.em.get_uid()][1]) + str(self.eee[self.em.get_uid()][2])}'
                  f'工资:{str(self.eee[self.em.get_uid()][4])}')
        else:
            print('UID不存在')

# 各类员工级别数量如下：
# 普通员工：10 级
# 组长：6 级
# 经理：3 级
# 升级功能：支持增加多级；当超过当前职位最高级别时，进行升职操作（无论增加多少个级别，只要发生升职，级别一律初始化为 1 级，见程序实现截图）.
    def up_grade(self):
        print('up_grade', self.eee)
        # self.uid =input('请输入UID')
        self.uid = '10001'
        print(int(self.uid) in self.eee)
        if int(self.uid) in self.eee:
            self.eee[self.em.get_uid()][2]=int(self.eee[self.em.get_uid()][2])+1
            print(f'升级成功！ name:{self.eee[self.em.get_uid()][0]} '
                  f'职称:{str(self.eee[self.em.get_uid()][1]) + str(self.eee[self.em.get_uid()][2])}'
                  f'工资:{str(self.eee[self.em.get_uid()][4])}')
        else:
            print('UID不存在')
# 降级功能：支持减少多级；当超过当前职位最高级别时，进行升职操作（无论减少多少个级别，只要发生降职，级别一律初始化为当前职位最高级别，见程序实现截图）
    def down_grade(self):
        print('up_grade', self.eee)
        # self.uid =input('请输入UID')
        self.uid = '10001'
        print(int(self.uid) in self.eee)
        if int(self.uid) in self.eee:
            self.eee[self.em.get_uid()][2]=int(self.eee[self.em.get_uid()][2])-1
            print(f'降级成功！ name:{self.eee[self.em.get_uid()][0]} '
                  f'职称:{str(self.eee[self.em.get_uid()][1]) + str(self.eee[self.em.get_uid()][2])}'
                  f'工资:{str(self.eee[self.em.get_uid()][4])}')
        else:
            print('UID不存在')
m = Manager()
m.inEmployee()
m.checkEmployee()
m.up_grade()
m.down_grade()

条纹领带

非常感谢