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

zhangyh0622

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

1

boyi-y

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()           
            

donglincao

1

oslen

Artemis_

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 = [3000, 500, 50]
        self.Teamleader = [4000, 800, 100]
        self.Manager = [5000, 1000, 1000]

# 员工信息类
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[0] + base[1]*self.grade + base[2]*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[self.uid] = emp
        print(self.employees)
        print(self.employees[self.uid].sala)
        print(f'录入成功！姓名：{self.employees[self.uid].name}，工号：{self.uid}，薪资：{self.employees[self.uid].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[userid].name}')
            print(f'职位：{self.employees[userid].job}')
            print(f'级别：{self.employees[userid].grade}')
            print(f'工龄：{self.employees[userid].year}')
            print(f'薪资：{self.employees[userid].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[each].job == jobtem:
                    count += 1
                    personlist.append(' - '.join([str(self.employees[each].uid),self.employees[each].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[userid].name}，工号：{userid}，当前职位：{self.employees[userid].job}+{self.employees[userid].grade}，当前薪资：{self.employees[userid].salary()}')
        up = int(input('请输入需要增加的级数：'))
        mark = 1
        oldsala = self.employees[userid].salary()
        self.employees[userid].grade += up
        res = self.promotecheck(mark, self.employees[userid].job, self.employees[userid].grade)
        self.employees[userid].job = res[0]
        self.employees[userid].grade = res[1]
        print('升级成功！')
        print(f'{self.employees[userid].get_name()}，工号：{userid}，升级后职位：{self.employees[userid].get_job()}+{self.employees[userid].get_grade()}，升级后薪资：{self.employees[userid].salary()}（+{self.employees[userid].salary() - oldsala}）')

    # 降级
    def downgrade(self):
        userid = int(input('请输入工号：'))
        while not userid in self.employees.keys():
            userid = input('工号不存在，请重新输入：')
        print(f'{self.employees[userid].name}，工号：{userid}，当前职位：{self.employees[userid].job}+{self.employees[userid].grade}，当前薪资：{self.employees[userid].salary()}')
        down = int(input('请输入需要减少的级数：'))
        mark = 0
        oldsala = self.employees[userid].salary()
        self.employees[userid].grade -= down
        res = self.promotecheck(mark, self.employees[userid].job, self.employees[userid].grade)
        self.employees[userid].job = res[0]
        self.employees[userid].grade = res[1]
        print('降级成功！')
        print(f'{self.employees[userid].get_name()}，工号：{userid}，降级后职位：{self.employees[userid].get_job()}+{self.employees[userid].get_grade()}，降级后薪资：{self.employees[userid].salary()}({self.employees[userid].salary() - oldsala})')

def main():
    e = Manage()
    e.welcome()

main()

battery

已思考

陈年老咸鱼

yangmiao07

1

语冰

1

nmdorceo

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[self.job][self.uid] = 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[self.__job]) != 0:
            print(f"目前普通员工共有{len(self.Managerdict[self.__job])}人：")
            for i in self.Managerdict[self.__job]:
                print(f"{i} - {self.Managerdict[self.__job][i].name}", "\n")
        else:
            self.__dict = {"E":"普通员工", "T":"组长", "M":"经理"}
            print(f"目前公司没有{self.__dict[self.__job]}!", "\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[self.__uid].job = self.job
                i[self.__uid].grade = self.grade
                super().salarycompute(i.get(self.__uid).job, i.get(self.__uid).grade, i.get(self.__uid).year)
                i[self.__uid].salary = self.salary
                self.now_salary = i.get(self.__uid).salary
                self.__updatedict = i.pop(self.__uid)
                self.Managerdict[self.job][self.__uid] = 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[self.__uid].job = self.job
                i[self.__uid].grade = self.grade
                super().salarycompute(i.get(self.__uid).job, i.get(self.__uid).grade, i.get(self.__uid).year)
                i[self.__uid].salary = self.salary
                self.now_salary = i.get(self.__uid).salary
                self.__updatedict = i.pop(self.__uid)
                self.Managerdict[self.job][self.__uid] = 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()

wtc

来了

CoupleHunnid

人间无事人

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.不算吧，只是做了默认参数的功能

么11

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.

1. class Men:
   
2.     uid = 10000
   
3.     def __init__(self, name = None, job = None, grade = 0, year = 0):
   
4.         self.name = name
   
5.         self.job = job
   
6.         self.grade = grade
   
7.         self.year = year
   
8. 
   
9.     def get_name(self):
   
10.         self.name = input("姓名：")
    
11.         return self.name
    
12.         
    
13.     def get_job(self):
    
14.         self.job = input("职位（E.普通员工；T.组长；M.经理）：")
    
15.         return self.job
    
16.         
    
17.     def get_grade(self):
    
18.         self.grade = int(input("级别："))
    
19.         return self.grade
    
20.         
    
21.     def get_year(self):
    
22.         self.year = int(input("工龄："))
    
23.         return self.year
    
24.         
    
25.     def get_uid(self):
    
26.         return self.uid
    
27. 
    
28.     def p(self):
    
29.         print(self.gather[10000].__dict__)
    
30. #-----------------------------------------------------------------------------------------------        
    
31. class Employee(Men):
    
32.     gather = {}
    
33.     def salary(self, grade, year):
    
34.         return (3000 + 500 * grade + 50 * year)
    
35.    
    
36. class Teamleader(Men):
    
37.     gather = {}
    
38.     def salary(self, grade, year):
    
39.         return (4000 + 800 * grade + 100 * year)
    
40. 
    
41. class Manager(Men):
    
42.     gather = {}
    
43.     def salary(self, grade, year):
    
44.         return (5000 + 1000 * (grade + year))
    
45. #-----------------------------------------------------------------------------------------------   
    
46. def get_salary(job, grade, year):
    
47.     if job == "E":
    
48.         s = Employee()
    
49.         while grade > 10 or grade <= 0:
    
50.             grade = int(input("该职位最高级别为10，请重新输入:"))
    
51.     if job == "T":
    
52.         s = Teamleader()
    
53.         while grade > 6 or grade <= 0:
    
54.             grade = int(input("该职位最高级别为6，请重新输入:"))
    
55.     if job == "M":
    
56.         s = Manager()
    
57.         while grade > 3 or grade <= 0:
    
58.             grade = int(input("该职位最高级别为3，请重新输入:"))
    
59.     return (s.salary(grade, year), grade)
    
60. 
    
61. def get_group(job,men):
    
62.     if job == "E":
    
63.         s = Employee()
    
64.         s.gather[Men.uid] = men
    
65.     if job == "T":
    
66.         s = Teamleader()
    
67.         s.gather[Men.uid] = men
    
68.     if job == "M":
    
69.         s = Manager()
    
70.         s.gather[Men.uid] = men
    
71. #-----------------------------------------------------------------------------------------------
    
72. class Mange(Men):
    
73.     gather = {}
    
74.     def lu_ru(self):
    
75.         name = self.get_name()
    
76.         job = self.get_job()
    
77.         year = self.get_year()
    
78.         grade = self.get_grade()
    
79.         sal, grade = get_salary(job, grade, year)
    
80.         men = Men(name, job, grade, year)
    
81.         men.salary = sal
    
82.         self.gather[Men.uid] = men
    
83.         get_group(job,men)
    
84.         print(self.gather[Men.uid].__dict__)
    
85.         Men.uid += 1
    
86.         
    
87.     def cha_xu_01(self):
    
88.         gong_hao = int(input("请输入工号："))
    
89.         print(self.gather)
    
90.         if not self.gather.get(gong_hao):
    
91.             print("工号不存在！")
    
92.         else:
    
93.             print("姓名：", self.gather[gong_hao].name)
    
94.             print("职位：", self.gather[gong_hao].job)
    
95.             print("级别：", self.gather[gong_hao].grade)
    
96.             print("工龄：", self.gather[gong_hao].year)
    
97.             print("薪资：", self.gather[gong_hao].salary)
    
98.     def cha_xu_02(self):
    
99.         zhi_wei = input("职位（E.普通员工；T.组长；M.经理）:")
    
100.         if zhi_wei == "E":
     
101.             s = Employee()
     
102.             print(f"目前普通员工有{ len(s.gather)}人")
     
103.             for i in s.gather:
     
104.                 print("工号：", i, "姓名：", s.gather[i].name)
     
105.         elif zhi_wei == "T":
     
106.             s = Teamleader()
     
107.             print(f"目前组长有{ len(s.gather)}人")
     
108.         elif jzhi_weiob == "M":
     
109.             s = Manager()
     
110.             print(f"目前经理有{ len(s.gather)}人")  
     
111.         else:
     
112.             print("职位不存在！")
     
113.     def cha_xu(self):
     
114.         one_or_two = int(input("1.员工查询；2.职位查询："))
     
115.         if one_or_two == 1:
     
116.             self.cha_xu_01()
     
117.         elif one_or_two == 2:
     
118.             self.cha_xu_02()
     
119.             
     
120.     def sheng_zhi(self):
     
121.         num = int(input("请输入工号："))
     
122.         if self.gather.get(num):
     
123.             print(f"{self.gather[num].name}, 工号：{num}， 当前职位{self.gather[num].job}{self.gather[num].grade}, 当前薪资：{self.gather[num].salary}")
     
124.         else:
     
125.             print("工号不存在！")
     
126.         up_num = int(input("请输入需要增加的级数："))
     
127.         if self.gather[num].job == "E":
     
128.             base = self.gather[num].grade + up_num
     
129.             if base > 10:
     
130.                 self.gather[num].job = "T"
     
131.                 self.gather[num].grade = 1
     
132.                 sal, grade = get_salary(self.gather[num].job, self.gather[num].grade, self.gather[num].year)
     
133.                 self.gather[num].salary = sal
     
134.                 print("升职成功！")
     
135.                 print(f"{self.gather[num].name}, 工号：{num}， 升职后职位{self.gather[num].job}{self.gather[num].grade}, 升职后薪资：{self.gather[num].salary}")
     
136.                 return
     
137.             else:
     
138.                 self.gather[num].grade = base
     
139.                 sal, grade = get_salary(self.gather[num].job, self.gather[num].grade, self.gather[num].year)
     
140.                 self.gather[num].salary = sal
     
141.                 print("升职成功！")
     
142.                 print(f"{self.gather[num].name}, 工号：{num}， 升职后职位:{self.gather[num].job}{self.gather[num].grade}, 升职后薪资：{self.gather[num].salary}")
     
143.                 return
     
144.         if self.gather[num].job == "T":
     
145.             base = self.gather[num].grade + up_num
     
146.             if base > 6:
     
147.                 self.gather[num].job = "M"
     
148.                 self.gather[num].grade = 1
     
149.                 sal, grade = get_salary(self.gather[num].job, self.gather[num].grade, self.gather[num].year)
     
150.                 self.gather[num].salary = sal
     
151.                 print("升职成功！")
     
152.                 print(f"{self.gather[num].name},工号：{num}，升职后职位:{self.gather[num].job}{self.gather[num].grade}, 升职后薪资：{self.gather[num].salary}")
     
153.                 return
     
154.             else:
     
155.                 self.gather[num].grade = base
     
156.                 sal, grade = get_salary(self.gather[num].job, self.gather[num].grade, self.gather[num].year)
     
157.                 self.gather[num].salary = sal
     
158.                 print("升职成功！")
     
159.                 print(f"{self.gather[num].name}, 工号：{num}， 升职后职位:{self.gather[num].job}{self.gather[num].grade}, 升职后薪资：{self.gather[num].salary}")
     
160.                 return
     
161.         if self.gather[num].job == "M":
     
162.             base = self.gather[num].grade + up_num
     
163.             if base > 3:
     
164.                 self.gather[num].grade = 3
     
165.                 sal, grade = get_salary(self.gather[num].job, self.gather[num].grade, self.gather[num].year)
     
166.                 self.gather[num].salary = sal
     
167.                 print("升职成功！已是最高职位了")
     
168.                 print(f"{self.gather[num].name}, 工号：{num}， 升职后职位{self.gather[num].job}{self.gather[num].grade}, 升职后薪资：{self.gather[num].salary}")
     
169.                 return
     
170.             else:
     
171.                 self.gather[num].grade = base
     
172.                 sal, grade = get_salary(self.gather[num].job, self.gather[num].grade, self.gather[num].year)
     
173.                 self.gather[num].salary = sal
     
174.                 print("升职成功！")
     
175.                 print(f"{self.gather[num].name},工号：{num},升职后职位{self.gather[num].job}{self.gather[num].grade}, 升职后薪资：{self.gather[num].salary}")
     
176.                 return
     
177. #-----------------------------------------------------------------------------------------------
     
178. def main():
     
179.     m = Mange()
     
180.     while True:
     
181.         order = input("1.录入；2.查询；3.升职；4.降职；5.退出：")
     
182.         if order == '5':
     
183.             print("已退出。")
     
184.             break
     
185.         elif order == '1':
     
186.             m.lu_ru()
     
187.         elif order == '2':
     
188.             m.cha_xu()
     
189.         elif order == '3':
     
190.             m.sheng_zhi()
     
191. 
     
192. main()

复制代码

小小孛

0

lbh8399

0.一个方法可以用在不同类型的数据上
1.可以让方法使用更加简洁
2.可以的
3.
4.降低耦合
5.不是

阿伟同学

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:
    def  is_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[job][1], self.job_state[job][2]

        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 [each for each in "ETM"]:
            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[job][1], self.job_state[job][2]        
        r = self.jin_wei_qi(min_grade, max_grade, grade, c)
        l = list(self.jobs.keys())
        if r == -1:
            if job != l[0]:
                self.jobs[job].remove(staff)
                index = l.index(job) - 1
                self.jobs[l[index]].append(staff)
                return l[index] + str(self.job_state[l[index]][2])
            else:
                return l[0] + self.job_state[l[0]][1]
        elif r == 1:
            if job != l[-1]:
                self.jobs[job].remove(staff)
                index = l.index(job) + 1
                self.jobs[l[index]].append(staff)
                return l[index] + str(self.job_state[l[index]][1])
            else:
                return l[-1] + self.job_state[l[-1]][2]
        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[self.uid] = staff
        self.jobs[job].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[uid]
                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[job]:
                print(f"目前公司没有{self.job_state[job][0]}！")
            else:
                print(f"目前{self.job_state[job][0]}共有 {len(self.jobs[job])} 人:")
                for each in self.jobs[job]:
                    print(f"{each.uid} - {each.name}")

    def upgrade(self):
        uid = self.is_uid_exist()
        if not uid:
            print("该工号不存在！")
        else:
            staff = self.staffs[uid]
            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[0]
            staff.grade = int(job[1:])
            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[uid]
            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[0]
            staff.grade = int(job[1:])
            print("降级成功！")
            print(f"{staff.name}, 工号：{staff.uid}, 升职后职位：{staff.job + str(staff.grade)}，当前薪资：{staff.salary()}({staff.salary() - salary:+})")            

def main():
    m = Manage()
    m.manage()