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

Superfreak

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

Walson777

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

凯文1

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：不同类的对象对同一消息做出响应

第 1 题的答案是：代码重用和扩展性，简化接口

第 2 题的答案是：算

第 3 题的答案是：如果它走起来像鸭子，叫声像鸭子，那它很可能就是一只鸭子。

第 4 题的答案是：内聚

第 5 题的答案是：不算

-------- 动动手 --------

请将第 0 题的代码写在下方：

自行车vcd

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：
通过类写出特性，在函数里统一调用

第 1 题的答案是：
便于调用

第 2 题的答案是：
可以

第 3 题的答案是：
如果它走起来像鸭子，叫起来也像鸭子，那么它就是鸭子

第 4 题的答案是：
降低了耦合度

第 5 题的答案是：
属于

-------- 动动手 --------

请将第 0 题的代码写在下方：
class Members:
    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):
        self.uid+=1
        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':
            return 3000+500*self.grade+50*self.year
        if ob=='T':
            return 4000+800*self.grade+100*self.year
        if job=='M':
            return 5000+1000*(self.grade+self.year)

class GradeMixin:
    #进行级别检测
    def is_tooheigh(self,grade,job):
        if job=='E':
            while grade>10:
                grade=int(input('该职位最高级别为10，请重新录入级别：'))
        if job=='T':
            while grade>6:
                grade=int(input('该职位最高级别为6，请重新录入级别：'))
        if job=='M':
            while grade>3:
                grade=int(input('该职位最高级别为3，请重新录入级别：'))
        return grade
            

class Manage(GradeMixin):
    def __init__(self):
        self.members={}
        self.uid=10000
        
    def welcome(self):
        ins=0
        while ins!='5':
            ins=input('1.录入;2.查询;3.升级;4.降级;5.退出：')
            if ins=='1':
                pass
            if ins=='2':
                pass
            if ins=='3':
                pass
            if ins=='4':
                pass
            
    def confirm_passwd(self):
        uid=int(input('请输入工号：'))
        if self.members.get(uid)==None:
            print('该工号不存在!')
        return uid

    def create_member(self):
        name=input('姓名：')
        job=input('职位（E.普通员工;T.组长;M.经理;）：')
        year=int(input('工龄：'))
        grade=int(input('级别:'))
        grade=self.is_tooheigh(grade,job)
        member=Member(name,job,grade,year,self.uid)
        self.members[self.uid]=member
        print(f"录入成功！姓名：{name},工号：{self.uid}，薪资：{Member().salary(job)}")
        self.uid+=1
        
    def member_chaxun(self):
        a=input('1.员工查询;2.职位查询：')
        if a=='1':
            uid=self.confim_passwd()
            print(f"姓名：{self.members[uid].name}\n职位：{self.members[uid].job}\n级别：{self.members[uid].grade}\n工龄：{self.members[uid].year}\n薪资：{Member().salary(self.members[uid].job)}")
        if a=='2':
            job=input('职位（E.普通员工;T.组长;M.经理;）：')
            if job=='E':
                       
                print(f"")
            if job=='T':
               
            if job=='M':

2666

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：0

第 1 题的答案是：1

第 2 题的答案是：2

第 3 题的答案是：3

第 4 题的答案是：4

第 5 题的答案是：5

-------- 动动手 --------

请将第 0 题的代码写在下方：0

Alexa_

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

Python是一门动态语言。在类和对象中，Python可以通过子类对父类方法的重写来体现多态特性

第 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 题的代码写在下方：

class Stuff:

    def __init__(self):
        self.stuff = {}
        self.next_uid = 10000

# 选择功能
    def welcome(self):
        while True:
            order = int(input("\n1.录入；2.查询；3.升级；4.降级；5.退出："))
            
            if order == 1:
                self.record()
            if order == 2:
                self.query()
            if order == 3:
                self.level_change(3)
            if order == 4:
                self.level_change(4)
            if order == 5:
                break

# 员工方法
    def get_uid(self):
        uid = self.next_uid
        self.next_uid += 1
        return uid
    def get_name(self):
        name = input("姓名：")
        return name
    def get_job(self):      
        job = input("职位（E.普通员工；T.组长；M.经理）：")
        return job
    def get_year(self):      
        year = int(input("工龄："))
        return year
    def get_grade(self):        
        grade = int(input("级别："))
        return grade
    def salary(self):
        pass

# 级别检查
    def grade_check(self, grade, job):
        if job == 'E':
            while grade > 10:
                grade = int(input("该职位最高级别为10，请重新输入级别："))
        elif job == 'T':
            while grade > 6:
                grade = int(input("该职位最高级别为6，请重新输入级别："))
        elif job == 'M':
            while grade > 3:
                grade = int(input("该职位最高级别为3，请重新输入级别："))
        return grade

# 录入
    def record(self):

        uid = self.get_uid()
        name = self.get_name()
        job = self.get_job()
        year = self.get_year()
        grade = self.get_grade()
        grade = self.grade_check(grade, job)

        if job == 'E':
            stuff = Employee(uid, name, job, year, grade)
        elif job == 'T':
            stuff = Teamleader(uid, name, job, year, grade)
        elif job == 'M':
            stuff = Manager(uid, name, job, year, grade)

        stuff.salary = stuff.get_salary(grade, year)

        self.stuff[stuff.uid] = stuff
        print(f'录入成功！姓名：{stuff.name}，工号：{stuff.uid}，薪资：{stuff.salary}')

# 查询
    def query(self):

        func = int(input("1.员工查询；2.职位查询："))

        if func == 1:
            uid_to_check = int(input("请输入工号："))
            if uid_to_check not in self.stuff:
                print("该工号不存在！")
            else:
                stuff = self.stuff[uid_to_check]
                print(f'姓名：{stuff.name}\n职位：{stuff.job}\n级别：{stuff.grade}\n工龄：{stuff.year}\n薪资：{stuff.salary}')
        
        if func == 2:
            job_to_check = input("职位（E.普通员工；T.组长；M.经理）：")
            job_list = {"E":"普通员工", "T":"组长", "M":"经理"}
            num = 0
            l = []
            for uid, stuff in self.stuff.items():
                if stuff.job == job_to_check:
                    num += 1
                    l.append(stuff)
            if num != 0:
                print(f"目前{job_list[job_to_check]}共有 {num} 人；")
                for stuff in l:
                    print(f"{stuff.uid} - {stuff.name}")
            else:
                print(f"目前公司没有{job_list[job_to_check]}！")

# 级别改变功能实现
    def level_change(self,order=None):

        uid_to_change = int(input("请输入工号："))
        stuff = self.stuff[uid_to_change]
        print(f'{stuff.name}，工号：{stuff.uid}，当前职位：{stuff.job+str(stuff.grade)}，当前薪资：{stuff.salary}')
        
        old_salary = stuff.salary
        
        if order == 3:
            level_to_change = "+" + input("请输入需要增加的级数：")
        elif order == 4:
            level_to_change = "-" + input("请输入需要减少的级数：")

        level_now, job_now = stuff.job_change(eval(level_to_change))

        if job_now == "E":
            stuff = Employee(stuff.uid, stuff.name, job_now, stuff.year,level_now) # 这里没有创建salary属性，也就是说salary现在不可调用
            self.stuff[stuff.uid] = stuff
        elif job_now == "T":
            stuff = Teamleader(stuff.uid, stuff.name, job_now, stuff.year,level_now)
            self.stuff[stuff.uid] = stuff
        elif job_now == "M":
            stuff = Manager(stuff.uid, stuff.name, job_now, stuff.year, level_now)
            self.stuff[stuff.uid] = stuff

        stuff.salary = stuff.get_salary(stuff.grade, stuff.year)
        salary_change = stuff.salary - old_salary

        if order == 3:
            print("升级成功！")
            print(f"{stuff.name}，工号：{stuff.uid}，升级后职位：{stuff.job+str(stuff.grade)}，升级后薪资：{stuff.salary}（{'{:+}'.format(salary_change)}）")
        elif order == 4:
            print("降级成功！")
            print(f"{stuff.name}，工号：{stuff.uid}，降级后职位：{stuff.job+str(stuff.grade)}，降级后薪资：{stuff.salary}（{'{:+}'.format(salary_change)}）")




class Employee(Stuff):
   
    def __init__(self, uid, name, job, year, grade):
        self.uid = uid
        self.name = name
        self.job = job
        self.year = year
        self.grade = grade

    def get_salary(self, grade, year):
        self.salary = 3000 + 500 * grade + 50 * year
        return self.salary
   
    def job_change(self, level_to_change):

        total = self.grade + level_to_change

        if total <= 10:
            level_now = total
            job_now = "E"
        if total > 10 and total <= 16:
            level_now = 1
            job_now = "T"
        if total > 16 and total <= 19:
            level_now = 1
            job_now = "M"

        return level_now, job_now

class Teamleader(Stuff):

    def __init__(self, uid, name, job, year, grade):
        self.uid = uid
        self.name = name
        self.job = job
        self.year = year
        self.grade = grade

    def get_salary(self, grade, year):
        self.salary = 4000 + 800 * grade + 100 * year
        return self.salary
   
    def job_change(self, level_to_change):

        total = 10 + self.grade + level_to_change

        if total <= 10:
            level_now = 10
            job_now = "E"
        if total > 10 and total <= 16:
            level_now = total - 10
            job_now = "T"
        if total > 16 and total <= 19:
            level_now = 1
            job_now = "M"

        return level_now, job_now

   
   
class Manager(Stuff):

    def __init__(self, uid, name, job, year, grade):
        self.uid = uid
        self.name = name
        self.job = job
        self.year = year
        self.grade = grade

    def get_salary(self, grade, year):
        self.salary = 5000 + 1000 * (grade + year)
        return self.salary
   
    def job_change(self, level_to_change):

        total = 16 + self.grade + level_to_change

        if total <= 10:
            level_now = 10
            job_now = "E"
        if total > 10 and total <= 16:
            level_now = 6
            job_now = "T"
        if total > 16 and total <= 19:
            level_now = total - 16
            job_now = "M"
            
        return level_now, job_now
   

def main():
    s = Stuff()
    s.welcome()

main()

18874875949

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：
多态的优势，一个模板，只要符合要求就能套壳使用
第 2 题的答案是：
可以称为多态
第 3 题的答案是：
不知道
第 4 题的答案是：
增强了内聚
第 5 题的答案是
是的
-------- 动动手 --------

请将第 0 题的代码写在下方：

miyum

请回复您的答案^_^
0，子类可以继承父类方法并重写

1，不同类型的对象，调用同一个方法得到不同的结果

2，是

3，

4，增强内聚

5，不算

class Employee:
    edict = {}
    elist = []
    def __init__(self,name,job,grade,year):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
        self.uid = len(self.elist)+10000
        self.total = 0

    def salary_employee(self,job,grade):
        if job == 'E':
            self.total = 3000+500*int(grade)+50*int(year)
        elif self.job == 'T':
            self.total = 4000+800*int(grade)+100*int(year)
        elif self.job == 'M':
            self.total = 5000+1000*(int(grade)+int(year))
        else:
            print("输入有误~")
        return self.total

    def add_employee(self):
        self.salary_employee(self.job,self.grade)
        self.edict[self.uid] = {"姓名":self.name,"职位":self.job,"级别":self.grade,"工龄":self.year,"薪资":self.total}
        self.elist.append(self.edict)
        print(f'录入成功！姓名：{self.name},工号：{self.uid},薪资：{self.total}')
   
    def get_name(self,uid):
        return self.edict[uid]["姓名"]
            
    def get_job(self,uid):
        return self.edict[uid]["职位"]

    def get_grade(self,uid):
        return self.edict[uid]["级别"]

    def get_year(self,uid):
        return self.edict[uid]["工龄"]

    def get_salary(self,uid):
        return self.edict[uid]["薪资"]

    def count_job(self,job):
        count = 0
        select_dict = {}
        for key,value in self.edict.items():
            if value["职位"] == job:
                count +=1
                select_dict[key] = value['姓名']
            match job:
                case 'E':
                    print(f"目前普通员工共有{count}人：")
                case 'T':
                    print(f"目前组长共有{count}人:")  
                case 'M':
                    print(f"目前经理共有{count}人:")
                           
            for key,value in select_dict.items():
                print(f"{key} - {value}")


class LevelMixin(Employee):
     def check_level(self,job,grade,temp_level):
        
        while True:
            if job == 'E' and grade+temp_level >10:
                temp_level = int(input("该职位最高级为10，请输入新的级别："))
            elif job == 'T' and grade+temp_level > 6:
                temp_level = int(input("该职位最高级为6，请输入新的级别："))
            elif job == 'M' and grade+temp_level >3:
                temp_level = int(input("该职位最高级为3，请输入新的级别："))
            elif job == 'E' and   0:
                return grade+temp_level
     def lower_level(self,uid):
          temp_level = int(input("请输入需要减少的级数："))
          new_level = self.check_level(job,grade,0-temp_level)
          new_salary = self.salary_employee(self.get_job(uid),new_level)
          print("降级成功！")
          print(f"{emp.get_name(uid)}，工号：{uid}，降级后的职位：{emp.get_job(uid)}{new_level}，升级后薪资：{new_salary}（-{emp.get_salary(uid)-new_salary}）")
          self.edict[uid]["薪资"] = new_salary
          self.edict[uid]["级别"] = new_level

     def add_level(self,job,grade):
          temp_level = int(input("请输入需要增加的级数："))
          new_level = self.check_level(job,grade,temp_level)
          new_salary = self.salary_employee(self.get_job(uid),new_level)
          print("升级成功！")
          print(f"{emp.get_name(uid)}，工号：{uid}，升级后的职位：{emp.get_job(uid)}{new_level}，升级后薪资：{new_salary}（+{new_salary-emp.get_salary(uid)}）")
          self.edict[uid]["薪资"] = new_salary
          self.edict[uid]["级别"] = new_level               

if __name__ == '__main__':
        while True:
            temp = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
            match temp:
                case '1':
                    name = input("姓名：")
                    job = input("职位：")
                    grade = int(input("级别："))
                    l = LevelMixin(1,1,1,1)
                    grade = l.check_level(job,grade,0)
                    year = int(input("工龄："))
                    emp = Employee(name,job,grade,year)
                    emp.add_employee()
                    continue
                case '2':
                    emp = Employee(1,1,1,1)
                    temp = input("1.员工查询；2.职位查询：")
                    match temp:
                        case '1':
                            temp_uid = int(input("请输入工号："))
                           
                            if temp_uid in emp.edict.keys():
                                print(f"姓名：{emp.get_name(temp_uid)}\n职位：{emp.get_job(temp_uid)}\n级别：{emp.get_grade(temp_uid)}\n工龄：{emp.get_year(temp_uid)}\n薪资：{emp.get_salary(temp_uid)}")
                                continue
                            else:
                                print("该工号不存在！！")
                            continue
                        case '2':
                            job = input("请输入职位(E.普通员工；T.组长；M.经理)：")

                            count_job = emp.count_job(job)
                            continue
                        case _:
                              print("输入有误！！！")
                    continue
                case '3':
                    lm = LevelMixin(1,1,1,1)
                    emp = Employee(1,1,1,1)
                    uid = int(input("请输入工号："))
                    print(f"{emp.get_name(uid)}，工号：{uid}，当前职位：{emp.get_job(uid)}{emp.get_grade(uid)}，当前薪资：{emp.get_salary(uid)}")
                    lm.add_level(emp.get_job(uid),emp.get_grade(uid))
                    continue
                    
                case '4':
                    uid = int(input("请输入工号："))
                    continue
                    pass
                case '5':
                    break
                case _:
                    print("输入有误！！！")
                    break





-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

wshxyl001

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：通过传入不同参数, 呈现不同的结果

第 1 题的答案是：代码的重复, 易于维护, 接口统一

第 2 题的答案是： 可以

第 3 题的答案是：

第 4 题的答案是：增强了内聚

第 5 题的答案是：不属于多态

-------- 动动手 --------

请将第 0 题的代码写在下方：

cleo8023

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

64991109

各位大佬这么写有没有问题，运行起来是正常的
class attribute:
    def __init__(self ,name ,job ,grade ,year ,uid):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
        self.uid = uid
    def get_uid(self):
        return self.uid
    def get_name(self):
        return self.name
    def get_job(self):
        return self.job
    def get_grade(self):
        return self.grade
    def get_year(self):
        return self.year
    def salary(self):
        if self.job == 'E':
            return 3000 + 500 * int(self.grade) + 50 * int(self.year)
        elif self.job == 'T':
            return 4000 + 800 * int(self.grade) + 100 * int(self.year)
        elif self.job == 'M':
            return 5000 + 1000 * (int(self.grade) + int(self.year))

class StaffMixin:
    def classification(self):
        post = input('职位(E.普通员工 T.组长 M.经理)')
        while post != 'E' and post != 'T' and post != 'M':
            post = input('输入错误，请输入职位代号（大写），E.普通员工 T.组长 M.经理')
        return post

    def up_rank(self,post,num):
        post = post[0] + str(int(post[1:])+int(num))
        if post[0] == 'E' and int(post[1:]) > 10:
            return 'T1'
        elif post[0] == 'T' and int(post[1:]) > 6:
            return 'M1'
        elif post[0] == 'M' and int(post[1:]) > 3:
            return 'M3'
        else:
            return post
    def down_rank(self,post,num):
        post = post[0] + str(int(post[1:])-int(num))
        if post[0] == 'E' and int(post[1:]) < 1:
            return 'E1'
        elif post[0] == 'T' and int(post[1:]) < 1:
            return 'E10'
        elif post[0] == 'M' and int(post[1:]) < 1:
            return 'T6'
        return post



class staff(StaffMixin):
    def __init__(self):
        self.staffs = {}
        self.uid = 10000

    def welcome(self):
        tag = ''
        while tag != '5':
            tag = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
            if tag == '1':
                self.enter()
            elif tag == '2':
                self.inquire()
            elif tag == '3':
                self.up_grade()
            elif tag == '4':
                self.down_grade()

    def grade_dec(self,job):
        grade = input('级别:')
        while 1:
            if job == 'E' and int(grade) > 10:
                grade = input('该职位最高级别为10，请重新输入:')
            elif job == 'T' and int(grade) > 6:
                grade = input('该职位最高级别为6，请重新输入：')
            elif job == 'M' and int(grade) > 3:
                grade = input('该职位最高级别为3，请重新输入：')
            else:
                return grade
    def enter(self):
        name = input("姓名：")
        job = self.classification()
        year = input('工龄:')
        grade = self.grade_dec(job)
        temp = attribute(name, job, grade, year, self.uid)
        self.staffs[self.uid] = temp
        print(f'录入成功!姓名:{self.staffs[self.uid].name},工号：{self.uid},薪资:{self.staffs[self.uid].salary()}')
        self.uid += 1
    def inquire(self):
        tag = input('1.员工查询，2.职位查询：')
        if tag == '1':
            uid = int(input('请输入工号：'))
            if not (uid in self.staffs):
                print('该工号不存在')
                return 0
            print(f'姓名：{self.staffs[uid].get_name()}')
            print(f'职位：{self.staffs[uid].get_job()}')
            print(f'级别：{self.staffs[uid].get_grade()}')
            print(f'工龄：{self.staffs[uid].get_year()}')
            print(f'工资：{self.staffs[uid].salary()}')
        elif tag == '2':
            job = input('职位（E.普通员工,T.组长,M经理）:')
            temp = 0
            for i in self.staffs.values():
                if i.get_job() == job:
                    print(f"{i.get_uid()}  -  {i.get_name()}")
                    temp = 1
            if temp == 0:
                if job == 'E':
                    print('目前没有普通员工！')
                elif job == 'T':
                    print('目前没有组长！')
                elif job == 'M':
                    print('目前没有经理！')
    def up_grade(self):
        uid = int(input('请输入工号：'))
        if not (uid in self.staffs):
            print('该工号不存在')
            return 0
        up_num = input('请输入需要增加的级数：')
        old_salary = self.staffs[uid].salary()
        temp = self.up_rank(self.staffs[uid].get_job()+self.staffs[uid].get_grade(),up_num)
        self.staffs[uid].job = temp[0]
        self.staffs[uid].grade = temp[1:]
        print('升级成功')
        print(f'{self.staffs[uid].get_name()}，工号{self.staffs[uid].get_uid()}，升级后职位{temp},升级后薪资：{self.staffs[uid].salary()}({self.staffs[uid].salary() - old_salary})')
    def down_grade(self):
        uid = int(input('请输入工号：'))
        if not (uid in self.staffs):
            print('该工号不存在')
            return 0
        down_num = input('请输入需要减少的级数：')
        old_salary = self.staffs[uid].salary()
        temp = self.down_rank(self.staffs[uid].get_job()+self.staffs[uid].get_grade(),down_num)
        self.staffs[uid].job = temp[0]
        self.staffs[uid].grade = temp[1:]
        print('降级成功')
        print(f'{self.staffs[uid].get_name()}，工号{self.staffs[uid].get_uid()}，降级后职位{temp},降级后薪资：{self.staffs[uid].salary()}({self.staffs[uid].salary() - old_salary})')
temp =staff()
temp.welcome()

Abnormalvis

-------- 动动手 --------

请将第 0 题的代码写在下方：
import time
#记录员工的关键信息
class staff:
    def __init__(self,uid,name,year,grade,job):
        self.uid = uid
        self.name = name
        self.year = year
        self.grade = grade
        self.job = job

class LoggerMixin:
    def log(self,message,filename='log（1）.txt'）:
            with open(filename,'a') as f:
            f.write(message)

class Manage(LoggerMixin):
    def __init__(self):
        self.staffs = {}
        self.uid = 10000

    def welcome(self):
        ins = 0
        print('欢迎使用公司员工查询系统！')
        while ins!=5:
            ins = ('\n1、录入；2、查询；3、升级；4、降级；5、退出：')
            if ins == '1':
                self.log_in_staff()
            if ins == '2':
                self.look_up_staff()
            if ins == '3':
                self.upgrade_staff()
            if ins == '4':
                self.downgrade_staff()
            if ins == '5':
                print('退出系统！')

   
    def confirm_uid(self):
        uid = int(input('请输入工号：'))
        while not self,uid,get(uid):
            uid = int(input('该卡号不存在，请重新输入:'))
        return uid
    def log_in_staff(self):
        name = input('请输入员工姓名：')
        A = input('职位（E.普通员工；T.组长；M.经理）')
        if A == 'E':
            job = '普通员工'
        elif A == 'T':
            job = '组长'
        elif A == 'M':
            job = '经理'
        year = int(input('请输入工龄：'))
        grade = int(input('请输入级别'))
        regdate = time.localtime()
        staff = staff(self.uid,name,year,grade,job,regdate)
        self.staff[self.uid] = staff
        print(f'员工信息录入成功：{self.uid}->{name},时间是:{time.strftime('%Y-%m-%d %H:%M:%S', regdate)}\n")
        self.uid += 1

    def look_up_staff(self):
        def get_uid(self):
            print(self.uid)
        def get_name(self):
            print(self.name)
        def get_job(self):
            print(self.job)
        def get_year(self):
            print(self.year)
        def get_grade(self):
            print(self.grade)
        def get_salary(self):
            if self.job == '普通员工':
                salary = 3000 + 500 * self.grade + self.year * 50
            if self.job == '组长':
                salary = 4000 + 800 * self.grade + self.year * 100
            if self.job = '经理':
                salary = 5000 + 1000 * (self.grade + self.year)
            return salary

    def upgrade_staff(self):
        num_upgraded = int(input('请输入升级的级数:'))
        if self.job = '普通员工':
            while num_upgraded + self.grade > 10:
                num_upgraded = input('非法录入，请重新输入：')
        if self.job = '组长':
            while num_upgraded + self.grade > 6:
                num_upgraded = input('非法录入，请重新输入：')
        if self.job = '经理':
            while num_upgraded + self.grade > 3:
                num_upgraded = input('非法录入，请重新输入：')

    def downgrade_staff(self):
        if self.job = '普通员工':
            while num_upgraded + self.grade < 1:
                num_upgraded = input('非法录入，请重新输入：')
        if self.job = '组长':
            while num_upgraded + self.grade < 1:
                num_upgraded = input('非法录入，请重新输入：')
        if self.job = '经理':
            while num_upgraded + self.grade < 1:
                num_upgraded = input('非法录入，请重新输入：')


def main():
    s = staff()
    s.welcome()

Abnormalvis

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：向同一个函数，传递不同参数后，可以实现不同功能.

第 1 题的答案是：
可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强；多态是调用方法的技巧，不会影响到类的内部设计。
第 2 题的答案是：可以

第 3 题的答案是：

第 4 题的答案是：增强了内聚

第 5 题的答案是：不是

zacefron

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

64991109

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

HT420

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：
不同对象对应的特性不同
第 1 题的答案是：
可以单独处理各自的内容
第 2 题的答案是：
可以
第 3 题的答案是：
不会
第 4 题的答案是：
高内聚
第 5 题的答案是：
不属于
-------- 动动手 --------

请将第 0 题的代码写在下方：
"""企业员工管理"""

class Employ:
    Employees = []
    Teamleaders = []
    Managers = []

    def __init__(self,name,job):
        if job == "普通员工":
            self.Employees.append(name)
        elif job == "组长":
            self.Teamleaders.append(name)
        elif job == "经理":
            self.Managers.append(name)

    def dispaly(self):
        print(f"普通员工：{self.Employees}")
        print(f"组长：{self.Teamleaders}")
        print(f"经理：{self.Managers}")

class jobs():

    sums = []
    yuangong = []
    dollers = []

    def __init__(self,name,job,grade,year,uid):

        self.yuangong = [name,job,grade,year,uid]
        self.sums.append(self.yuangong)

    def salary(self):

        if self.yuangong[1] == "普通员工":
            doller = 3000 + 500 * int(self.yuangong[2]) + 50 * int(self.yuangong[3])

        elif self.yuangong[1] == "组长":
            doller = 4000 + 800 * int(self.yuangong[2]) + 100 * int(self.yuangong[3])

        else:
            doller = 5000 + 1000 * int(self.yuangong[2]) + 1000 * int(self.yuangong[3])

        self.dollers.append(doller)
        return doller

def main():

    uid = 10000

    while True:
        choose = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))

        if choose == 1:
            name = input("姓名：")
            job1 = input("职位（E.普通员工；T.组长；M.经理）：")
            if job1 == 'E':
                job = "普通员工"
            elif job1 == 'T':
                job = "组长"
            elif job1 == 'M':
                job = "经理"
            year = int(input("工龄："))
            grade = int(input("级别："))

            e = Employ(name,job)
            js = jobs(name,job,grade,year,uid)
            s = js.salary()

            print(f"录入成功！姓名：{name}，工号：{uid}，薪资：{s}")
            uid = uid + 1

        if choose == 2:
            choose2 = int(input("1.员工查询；2.职位查询："))
            if choose2 == 1:
                n = -1
                uids = int(input("请输入工号:"))

                if uids <= uid:
                    for i in js.sums:
                        n = n + 1
                        if uids == int(i[4]):
                            print(f"姓名：{i[0]}")
                            print(f"职位：{i[1]}")
                            print(f"级别：{i[2]}")
                            print(f"工龄：{i[3]}")
                            print(f"薪资：{js.dollers[n]}")
                            break
                else:
                    print("该工号不存在！")

            else:
                jobss = input("职位（E.普通员工；T.组长；M.经理）：")

                if jobss == 'E':
                    E = e.Employees
                    print(f"普通员工共有{len(E)}人；")
                    if len(E) > 0:
                        for i in E:
                            print(f"{i}")

                elif jobss == 'T':
                    T = e.Teamleaders
                    print(f"组长共有{len(T)}人；")
                    if len(T) > 0:
                        for i in T:
                            print(f"{i}")

                elif jobss == 'M':
                    M = e.Managers
                    print(f"经理共有{len(M)}人；")
                    if len(M) > 0:
                        for i in M:
                            print(f"{i}")

        if choose == 3:


        if choose == 5:
            break

main()

Naud_Seong

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

huimie17

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：

jingtiandi123

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：
是
第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：
嗯
-------- 动动手 --------

请将第 0 题的代码写在下方：
class Method:
    def employee(self,grade,year):
        self.pay1 = 3000 + 500 * grade + 50* year
    def teamleader(self,grade,year):
        self.pay2 = 4000 + 800 * grade + 100* year
    def manager(self,grade,year):
        self.pay3 = 5000 + 1000 * (grade + year)
class Get:
    count = 0
    def get_uid(self):
        self.uid = 10000 + self.count
        self.count += 1
    def get_name(self):
        self.name = input('姓名：')
    def get_job(self):
        self.job = input('职位（E.普通员工；T.组长；M.经理）：')
    def get_year(self):
        self.year = int(input('工龄：'))
    def get_grade(self):
        self.grade = int(input('级别：'))
        if self.job == 'E':
            while self.grade < 0 or self.grade > 10:
                self.grade = int(input('该职位最低级别为1，最高级别为10，请重新录入级别：'))
        elif self.job == 'T':
            while self.grade < 0 or self.grade > 6:
                self.grade = int(input('该职位最低级别为1，最高级别为6，请重新录入级别：'))
        elif self.job == 'M':
            while self.grade < 0 or self.grade > 3:
                self.grade = int(input('该职位最低级别为1，最高级别为3，请重新录入级别：'))
    def get_salary(self,pay):
        self.salary = pay
class Function(Get,Method):
    player = {}
   
    def enroll(self):
        super().get_name()
        super().get_job()
        super().get_year()
        super().get_grade()
        super().get_uid()
        if self.job == 'E':
            super().employee(self.grade,self.year)
            super().get_salary(self.pay1)
        elif self.job == 'T':
            super().teamleader(self.grade,self.year)
            super().get_salary(self.pay2)
        elif self.job == 'M':
            super().manager(self.grade,self.year)
            super().get_salary(self.pay3)
        self.player[self.uid] = [self.name,self.job,self.year,self.grade,self.salary]
        print('录入成功！姓名：',self.name,'工号：',self.uid,'薪资：',self.salary)
    def inquiry(self):
        self.choice = int(input('1.员工查询；2.职位查询：'))
        if self.choice == 1:
            self.inquiry_uid = int(input('请输入工号：'))
            if self.inquiry_uid in self.player:
                print('姓名：',self.player[self.inquiry_uid][0])
                print('职位：',self.player[self.inquiry_uid][1])
                print('级别：',self.player[self.inquiry_uid][3])
                print('工龄：',self.player[self.inquiry_uid][2])
                print('薪资：',self.player[self.inquiry_uid][4])
            else:
                print('该工号不存在！')
        elif self.choice == 2:
            self.k = 0
            self.ku = []
            self.inquiry_job = input('职位（E.普通员工；T.组长；M.经理）：')
            for i in self.player:
                if self.inquiry_job in self.player[i]:
                    self.ku.append(f'{i} - {self.player[i][0]}')
                    self.k += 1
            if self.inquiry_job == 'E':
                print('目前普通员工共有',self.k,'人')
            elif self.inquiry_job == 'T':
                print('目前组长共有',self.k,'人')
            elif self.inquiry_job == 'M':
                print('目前经理共有',self.k,'人')
            if self.k != 0:
                for z in self.ku:
                    print(z)
            else:
                self.cun = {'E':'普通员工','T':'组长','M':'经理'}
                print('目前公司没有',self.cun[self.inquiry_job],'!',sep = '')
    def upgrade(self):
        self.upgrade_uid = int(input('请输入工号：'))
        if self.upgrade_uid in self.player:
            print(self.player[self.upgrade_uid][0],'工号：',self.upgrade_uid,'当前职位:',self.player[self.upgrade_uid][1]+str(self.player[self.upgrade_uid][3]),'当前薪资：',self.player[self.upgrade_uid][4])
            self.up_grade = int(input('请输入需要增加的级数：'))
            if self.player[self.upgrade_uid][1] == 'E':
                if self.player[self.upgrade_uid][3] + self.up_grade > 10:
                    self.player[self.upgrade_uid][1] = 'T'
                    self.player[self.upgrade_uid][3] = 1
                    super().teamleader(1,self.player[self.upgrade_uid][2])
                    self.price_difference = self.pay2 - self.player[self.upgrade_uid][4]
                    self.player[self.upgrade_uid][4] = self.pay2
                    print('升级成功！')
                else:
                    self.player[self.upgrade_uid][3] = self.player[self.upgrade_uid][3] + self.up_grade
                    super().employee(self.player[self.upgrade_uid][3],self.player[self.upgrade_uid][2])
                    self.price_difference = self.pay1 - self.player[self.upgrade_uid][4]
                    self.player[self.upgrade_uid][4] = self.pay1
                    print('升级成功！')
            elif self.player[self.upgrade_uid][1] == 'T':
                if self.player[self.upgrade_uid][3] + self.up_grade > 6:
                    self.player[self.upgrade_uid][1] = 'M'
                    self.player[self.upgrade_uid][3] = 1
                    super().manager(1,self.player[self.upgrade_uid][2])
                    self.price_difference = self.pay3 - self.player[self.upgrade_uid][4]
                    self.player[self.upgrade_uid][4] = self.pay3
                    print('升级成功！')
                else:
                    self.player[self.upgrade_uid][3] = self.player[self.upgrade_uid][3] + self.up_grade
                    super().teamleader(self.player[self.upgrade_uid][3],self.player[self.upgrade_uid][2])
                    self.price_difference = self.pay2 - self.player[self.upgrade_uid][4]
                    self.player[self.upgrade_uid][4] = self.pay2
                    print('升级成功！')
            elif self.player[self.upgrade_uid][1] == 'M':
                if self.player[self.upgrade_uid][3] + self.up_grade <= 3:
                    self.player[self.upgrade_uid][3] = self.player[self.upgrade_uid][3] + self.up_grade
                    super().manager(self.player[self.upgrade_uid][3],self.player[self.upgrade_uid][2])
                    self.price_difference = self.pay3 - self.player[self.upgrade_uid][4]
                    self.player[self.upgrade_uid][4] = self.pay3
                    print('升级成功！')
                else:
                    print('当前已达最高级别，无法进行升级！')
                    super().manager(self.player[self.upgrade_uid][3],self.player[self.upgrade_uid][2])
                    self.price_difference = self.pay3 - self.player[self.upgrade_uid][4]
                    self.player[self.upgrade_uid][4] = self.pay3
            print(self.player[self.upgrade_uid][0],'工号：',self.upgrade_uid,'升级后职位:',self.player[self.upgrade_uid][1]+str(self.player[self.upgrade_uid][3]),'升级后薪资：',self.player[self.upgrade_uid][4],f'(+{self.price_difference})')
        else:
            print('该工号不存在！')
    def degrade(self):
        self.degrade_uid = int(input('请输入工号：'))
        if self.degrade_uid in self.player:
            print(self.player[self.degrade_uid][0],'工号：',self.degrade_uid,'当前职位:',self.player[self.degrade_uid][1]+str(self.player[self.degrade_uid][3]),'当前薪资：',self.player[self.degrade_uid][4])
            self.de_grade = int(input('请输入需要减少的级数：'))   
            if self.player[self.degrade_uid][1] == 'E':
                if self.de_grade < self.player[self.degrade_uid][3]:
                    self.player[self.degrade_uid][3] = self.player[self.degrade_uid][3] - self.de_grade
                    super().employee(self.player[self.degrade_uid][3],self.player[self.degrade_uid][2])
                    self.price_difference = self.player[self.degrade_uid][4] - self.pay1
                    self.player[self.degrade_uid][4] = self.pay1
                    print('降级成功！')  
                else:
                    print('降级失败，超出级别范围！')
            elif self.player[self.degrade_uid][1] == 'T':
                if self.de_grade < self.player[self.degrade_uid][3]:
                    self.player[self.degrade_uid][3] = self.player[self.degrade_uid][3] - self.de_grade
                    super().teamleader(self.player[self.degrade_uid][3],self.player[self.degrade_uid][2])
                    self.price_difference = self.player[self.degrade_uid][4] - self.pay2
                    self.player[self.degrade_uid][4] = self.pay2
                    print('降级成功！')
                else:
                    self.player[self.degrade_uid][1] = 'E'
                    self.player[self.degrade_uid][3] = 10
                    super().employee(self.player[self.degrade_uid][3],self.player[self.degrade_uid][2])
                    self.price_difference = self.player[self.degrade_uid][4] - self.pay1
                    self.player[self.degrade_uid][4] = self.pay1
                    print('降级成功！')
            elif self.player[self.degrade_uid][1] == 'M':
                if self.de_grade < self.player[self.degrade_uid][3]:
                    self.player[self.degrade_uid][3] = self.player[self.degrade_uid][3] - self.de_grade
                    super().manager(self.player[self.degrade_uid][3],self.player[self.degrade_uid][2])
                    self.price_difference = self.player[self.degrade_uid][4] - self.pay3
                    self.player[self.degrade_uid][4] = self.pay3
                    print('降级成功！')
                else:
                    self.player[self.degrade_uid][1] = 'T'
                    self.player[self.degrade_uid][3] = 6
                    super().teamleader(self.player[self.degrade_uid][3],self.player[self.degrade_uid][2])
                    self.price_difference = self.player[self.degrade_uid][4] - self.pay2
                    self.player[self.degrade_uid][4] = self.pay2
                    print('降级成功！')
            print(self.player[self.degrade_uid][0],'工号：',self.degrade_uid,'降级后职位:',self.player[self.degrade_uid][1]+str(self.player[self.degrade_uid][3]),'降级后薪资：',self.player[self.degrade_uid][4],f'(-{self.price_difference})')
        else:
            print('该工号不存在！')

def main():
    c = Function()
    while True:
        print()
        temp = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
        if temp == '1':
            c.enroll()
        elif temp == '2':
            c.inquiry()
        elif temp == '3':
            c.upgrade()
        elif temp == '4':
            c.degrade()
        else:
            break

main()

qiao1316

请回复您的答案^_^

-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

-------- 动动手 --------

请将第 0 题的代码写在下方：