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

松怪怪

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

请回复您的答案^_^

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

第 0 题的答案是：
针对同一个函数/方法，根据传入的对象不同会有不同的结果

第 1 题的答案是：
可以直接封装好一段代码，然后调用不同类的对象可以实现不同的功能，一段代码就可以实现多种功能

第 2 题的答案是：
可以


第 3 题的答案是：
只要一只鸟走起来像鸭子，叫起来像鸭子，那么它就是鸭子

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


第 5 题的答案是：
属于，这里相当于传入了不同的对象能够有不同的结果

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

请将第 0 题的代码写在下方：
class Staff:
    def __init__(self, uid, name, job, grade, year):
        self.uid = uid
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
    def get_uid(self):
        return self.uid
    def get_name(self):
        return self.name
    def get_job(self):
        return self.job
    def get_grade(self):
        return self.grade
    def get_year(self):
        return self.year
    def get_salary(self):
        pass

class Employee(Staff):
    def __init__(self, uid, name, job, grade, year):
        super().__init__(uid, name, job, grade, year)
    def get_salary(self):
        return 3000+500*self.grade+50*self.year

class Teamleader(Staff):
    def __init__(self, uid, name, job, grade, year):
        super().__init__(uid, name, job, grade, year)
    def get_salary(self):
        return 4000+800*self.grade+100*self.year

class Manager(Staff):
    def __init__(self, uid, name, job, grade, year):
        super().__init__(uid, name, job, grade, year)
    def get_salary(self):
        return 5000+1000*(self.grade+self.year)


def enter(staff_lis):
    i = 0
    while True:
        uid = 10000 + i
        name = input("姓名：")
        job = input("职位（E.普通员工；T.组长；M.经理）：")
        year = int(input("工龄："))
        grade = int(input("级别："))
        if job == "E":
            while grade > 10:
                grade = int(input("该职位最高级别为10，请重新录入级别："))
            staff = Employee(uid, name, job, grade, year)
        elif job == "T":
            while grade > 6:
                grade = int(input("该职位最高级别为6，请重新录入级别："))
            staff = Teamleader(uid, name, job, grade, year)
        elif job == "M":
            while grade > 3:
                grade = int(input("该职位最高级别为3，请重新录入级别："))
            staff = Manager(uid, name, job, grade, year)
        staff_lis.append(staff)
        print(f"录入成功！姓名：{staff.name}， 工号：{staff.uid}，薪资：{staff.get_salary()}")
        yield staff
        i += 1

def query(staff_lis):
    cmd = int(input("1.员工查询；2.职位查询："))
    if cmd == 1:
        uid_q = int(input("请输入工号："))
        sum = 0
        for x in staff_lis:
            if uid_q == x.uid:
                sum += 1
                print("姓名：", x.name)
                print("职位：", x.job)
                print("级别：", x.grade)
                print("工龄：", x.year)
                print("薪资：", x.get_salary())
        if sum == 0:
            print("该工号不存在！")

    elif cmd == 2:
        job_dic = {"E":"普通员工", "T":"组长", "M":"经理"}
        job_q = input("职位（E.普通员工；T.组长；M.经理）：")
        job_name = job_dic[job_q]
        staff_q_lis = [x for x in staff_lis if x.job == job_q]
        if len(staff_q_lis) == 0:
            print(f"目前公司没有{job_name}")
        else:
            print(f"目前{job_name}共有{len(staff_q_lis)}人")
            for each in staff_q_lis:
                print(f"{each.uid} - {each.name}")

def up(staff_lis):
    uid = int(input("请输入工号："))
    sum = 0
    for x in staff_lis:
        if x.uid == uid:
            index = staff_lis.index(x)
            sum += 1
            salary_org = x.get_salary()
            print(x.name, "工号：", x.uid, "当前职位：", f"{x.job}", x.grade,
                  "当前薪资：", salary_org)
            up_num = int(input("请输入需要增加的级数："))
            level = x.grade + up_num
            if x.job == "E":
                if level > 10:
                    x.grade = 1
                    x.job = "T"
                    staff_lis[index] = Teamleader(x.uid, x.name, x.job, x.grade, x.year)
                    x = staff_lis[index]
                else:
                    x.grade = level
                print("升级成功！")
            elif x.job == "T":
                if level > 6:
                    x.grade = 1
                    x.job = "M"
                    staff_lis[index] = Manager(x.uid, x.name, x.job, x.grade, x.year)
                    x = staff_lis[index]
                else:
                    x.grade = level
                print("升级成功！")
            elif x.job == "M":
                if x.grade == 3:
                    print("您已到最高级别，无法再升级")
                elif level > 3:
                    x.grade = 3
                    print("升级成功！")
                else:
                    x.grade = level
                    print("升级成功！")
            print(x.name, "工号：", x.uid, "升级后职位：", f"{x.job}", x.grade,
                  "当前薪资：", x.get_salary(), f"（+{x.get_salary() - salary_org}）")
    if sum == 0:
        print("查无此人")


def down(staff_lis):
    uid = int(input("请输入工号："))
    sum = 0
    for x in staff_lis:
        if x.uid == uid:
            index = staff_lis.index(x)
            sum += 1
            salary_org = x.get_salary()
            print(x.name, "工号：", x.uid, "当前职位：", f"{x.job}：", x.grade,
                  "薪资：", salary_org)
            down_num = int(input("请输入需要减少的级数："))
            level = x.grade - down_num
            if x.job == "E":
                if level <= 0:
                    x.grade = 1
                    x.job = "E"
                else:
                    x.grade = level
                print("降级成功！")
            elif x.job == "T":
                if level <= 0:
                    x.grade = 10
                    x.job = "E"
                    staff_lis[index] = Employee(x.uid, x.name, x.job, x.grade, x.year)
                    x = staff_lis[index]
                else:
                    x.grade = level
                print("降级成功！")
            elif x.job == "M":
                if level <= 0:
                    x.grade = 6
                    x.job = "T"
                    staff_lis[index] = Teamleader(x.uid, x.name, x.job, x.grade, x.year)
                    x = staff_lis[index]
                else:
                    x.grade = level
                print("降级成功！")
            print(x.name, "工号：", x.uid, "升级后职位：", f"{x.job}：", x.grade,
                  "薪资：", x.get_salary(), f"（{x.get_salary() - salary_org}）")
    if sum == 0:
        print("查无此人")

def main():
    staff_lis = []
    iterator = enter(staff_lis)
    while True:
        command = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
        if command == 1:
            next(iterator)
        elif command == 2:
            query(staff_lis)
        elif command == 3:
            up(staff_lis)
        elif command == 4:
            down(staff_lis)
        elif command == 5:
            break

if __name__ == '__main__':
    main()

yuanyeguishu

请回复您的答案^_^

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

第 0 题的答案是：
在子类中对父类的方法再次定义
第 1 题的答案是：
减少重复操作  可以依次输入根据情况有不同结果
第 2 题的答案是：
可以
第 3 题的答案是：
看着是鸭子  .........
第 4 题的答案是：
鸭子类型和其他模块毫无瓜葛  只是被顶层调用  降低了耦合
第 5 题的答案是：
不是
-------- 动动手 --------

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

斯文0729

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

HAHAHABAO

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

nicolu

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

3352925169

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

Wendy_NL

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：可以

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

cold-dew-ai

请回复您的答案^_^

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

第 0 题的答案是：根据不同的对象执行不同的操作

第 1 题的答案是：减少代码重复

第 2 题的答案是：可以

第 3 题的答案是：看起来像鸭子，吃起来也像，那就是鸭子

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

第 5 题的答案是：是

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

请将第 0 题的代码写在下方：
class people:
    def __init__(self,name,job,grade,year,uid):
        self.name = name      #姓名
        self.job = job        #职位
        self.grade = grade    #级别
        self.year = year      #工龄
        self.uid = uid        #工号
    def salary(self):
        if self.job == 'E':
            return 3000 + 500 * int(self.grade) + 50 * int(self.year)
        if self.job == 'T':
            return 4000 + 800 * int(self.grade) + 100 * int(self.year)
        if self.job == 'M':
            return 5000 + 1000 * (int(self.grade) + int(self.year))
def main():
    word = {}
    uid = 10000
    while 1:
        print()
        x = input("1.录入;2.查询;3.升级;4.降级;5.退出：")
        if x == '1':
            name = input("姓名：")
            job = input("职位（E.普通员工;T.组长;M.经理）：")
            year = input("工龄：")
            grade = input("级别：")
            while job == "E" and int(grade) > 10:
                grade = input("该职位最高级别为10，请重新录入级别：")
            while job == "T" and int(grade) > 6:
                grade = input("该职位最高级别为6，请重新录入级别：")
            while job == "M" and int(grade) > 3:
                grade = input("该职位最高级别为3，请重新录入级别：")
            word[str(uid)] = people(name,job,grade,year,uid)
            print(f"录入成功！姓名：{name}，工号：{uid}，薪资：{word[str(uid)].salary()}")
            uid += 1
        elif x == '2':
            y = input("1.员工查询;2.职位查询：")
            if y == "1":
                z = input("请输入工号：")
                for i in word:
                    if i == z:
                        print(f"姓名：{word[i].name}")
                        print(f"职位：{word[i].job}")
                        print(f"级别：{word[i].grade}")
                        print(f"工龄：{word[i].year}")
                        print(f"薪资：{word[i].salary()}")
                        break
                else:
                    print("该工号不存在！")
            elif y == "2":
                job = input("职位（E.普通员工;T.组长;M.经理）：")
                while 1:
                    num = []
                    for i in word:
                        if word[i].job == job:
                            num.append(i)
                    if job == "E":
                        print(f"目前普通员工共有{len(num)}人：")
                        for i in num:
                            print(f"{i} - {word[i].name}")
                        break
                    elif job == "T":
                        print(f"目前组长共有{len(num)}人：")
                        for i in num:
                            print(f"{i} - {word[i].name}")
                        break
                    elif job == "M":
                        print(f"目前经理共有{len(num)}人：")
                        for i in num:
                            print(f"{i} - {word[i].name}")
                        break
                    else:
                        job = input("职位错误！请重新输入职位：")
        elif x == '3':
            y = input("请输入工号：")
            try:
                print(f"{word[y].name}，工号：{word[y].uid}，当前职位：{word[y].job + word[y].grade}，当前薪资：{word[y].salary()}")
                z = input("请输入需要增加的级数：")
                if word[y].job == 'E' and int(word[y].grade) + int(z) > 10:
                    word[y].job = 'T'
                    word[y].grade = '1'
                    print("升级成功！")
                elif word[y].job == 'T' and int(word[y].grade) + int(z) > 6:
                    word[y].job = 'M'
                    word[y].grade = '1'
                    print("升级成功！")
                elif word[y].job == 'M' and int(word[y].grade) + int(z) > 3:
                    print("升级失败！经理最高只能为3级")
                else:
                    word[y].grade = str(int(word[y].grade) + int(z))
                print(f"{word[y].name}，工号：{word[y].uid}，升级后职位：{word[y].job + word[y].grade}，升级后薪资：{word[y].salary()}")
            except:
                print("错误！该工号不存在！")
        elif x == '4':
            y = input("请输入工号：")
            try:
                print(f"{word[y].name}，工号：{word[y].uid}，当前职位：{word[y].job + word[y].grade}，当前薪资：{word[y].salary()}")
                z = input("请输入需要减少的级数：")
                if word[y].job == 'E' and int(word[y].grade) - int(z) < 1:
                    word.pop(y)
                    print("降级成功！该员工已被辞退！")
                elif word[y].job == 'T' and int(word[y].grade) - int(z) < 1:
                    word[y].job = 'E'
                    word[y].grade = '10'
                    print("降级成功！")
                elif word[y].job == 'M' and int(word[y].grade) - int(z) < 1:
                    word[y].job = 'T'
                    word[y].grade = '6'
                    print("降级成功！")
                else:
                    word[y].grade = str(int(word[y].grade) - int(z))
                print(f"{word[y].name}，工号：{word[y].uid}，降级后职位：{word[y].job + word[y].grade}，降级后薪资：{word[y].salary()}")
            except:
                print("错误！该工号不存在！")
        elif x == '5':
            break

M_mm

请回复您的答案^_^

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

第 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 get_grade(self):
        return self.grade
    def salary(self):
        return 3000 + 500*self.grade +50*self.year
class Teamleader(Employee):
    super().__init__()
    super().get_uid()
    super().get_name()
    super().get_job()
    super().get_year()
    super().get_grade()
    def salary(self):
        return 4000 + 800*self.grade + 100*self.year

class Manager(Employee):
    super().__init__()
    super().get_uid()
    super().get_name()
    super().get_job()
    super().get_year()
    super().get_grade()
    def salary(self):
        return 5000 + 1000*(self.grade + self.year)

luochaowei

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

2522014507

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

南瓜墩墩

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

yuehh_dyrcj

请回复您的答案^_^

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

第 0 题的答案是：
靠鸭子类型（不强制继承 / 接口）
第 1 题的答案是：
让代码更灵活、更好扩展、更易维护，同时减少重复逻辑。
第 2 题的答案是：
可以
第 3 题的答案是：
如果它走起路来像鸭子，叫起来也像鸭子，那它就是鸭子。
第 4 题的答案是：
鸭子类型优先体现为降低耦合，同时有利于高内聚。
第 5 题的答案是：
不是
-------- 动动手 --------

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

huayangshihan

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

zzj375100270

请回复您的答案^_^

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

第 0 题的答案是：重写

第 1 题的答案是：更灵活

第 2 题的答案是：可以

第 3 题的答案是：

第 4 题的答案是：内聚

第 5 题的答案是：属于

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

请将第 0 题的代码写在下方：
class Staff:
    def __init__(self, uid):
        self.uid = uid
        self.name = ""
        self.job = ""
        self.grade = 0
        self.year = 0
    def get_uid(self):
        return self.uid
    def get_name(self):
        return self.name
    def get_job(self):
        return self.job
    def get_grade(self):
        return self.grade
    def get_year(self):
        return self.year
    def get_salary(self):
        return self.salary()
    def get_level(self):
        return self.job + str(self.grade)
    def salary(self):
        pass

class Employee(Staff):
    def __init__(self, uid):
        super().__init__(uid)
        self.job = "E"
    def salary(self):
        return 3000 + self.grade * 500 + self.year * 50

class Teamleader(Staff):
    def __init__(self, uid):
        super().__init__(uid)
        self.job = "T"
    def salary(self):
        return 4000 + self.grade * 800 + self.year * 100

class Manager(Staff):
    def __init__(self, uid):
        super().__init__(uid)
        self.job = "M"
    def salary(self):
        return 5000 + 1000 * (self.grade + self.year)

class Management:
    def __init__(self):
        self.staffs = []
        self.uid = 10000
        
    def add_staff(self):
        name = input("姓名：")
        if not name:
            print("姓名不能为空！")
            return
        
        job = input("职位（E.普通员工;T.组长;M.经理）：")
        if job not in ["E", "T", "M"]:
            print("职位输入错误！")
            return
        
        if job == "E":
            staff = Employee(self.uid)
        elif job == "T":
            staff = Teamleader(self.uid)
        else:
            staff = Manager(self.uid)
        
        staff.name = name
        
        while True:
            try:
                year = int(input("工龄："))
                if year < 0:
                    print("工龄不能为负数！")
                    continue
                break
            except ValueError:
                print("请输入正确的数字！")
        staff.year = year
        
        job_grade_max = {"E": 10, "T": 6, "M": 3}
        while True:
            try:
                grade = int(input("级别："))
                if grade < 1 or grade > job_grade_max[job]:
                    print(f"级别输入错误！{job_grade_max[job]}级为最高级别")
                    continue
                break
            except ValueError:
                print("请输入正确的数字！")
        staff.grade = grade
        
        self.staffs.append(staff)
        self.uid += 1
        print(f"录入成功！姓名：{staff.name}，工号：{self.uid-1}，薪资：{staff.get_salary()}")

    def staff_search(self):
        while True:
            try:
                uid = int(input("请输入工号："))
                break
            except ValueError:
                print("请输入正确的数字！")
        
        found = False
        for staff in self.staffs:
            if staff.get_uid() == uid:
                print(f"姓名：{staff.get_name()}")
                print(f"职位：{staff.get_job()}")
                print(f"级别：{staff.get_grade()}")
                print(f"工龄：{staff.get_year()}")
                print(f"薪资：{staff.get_salary()}")
                found = True
                break
        if not found:
            print("该工号不存在！")
            return
        
    def job_search(self):
        level_lst = {"E":"普通员工","T":"组长","M":"经理"}
        job = input("职位（E.普通员工;T.组长;M.经理）：")
        if job not in level_lst:
            print("职位输入错误！")
            return
        
        staff_lst = []
        staff_count = 0
        for staff in self.staffs:
            if staff.get_job() == job:
                staff_lst.append(staff)
                staff_count += 1
        if staff_count == 0:
            print(f"目前公司没有{level_lst[job]}！")
            return
        else:
            print(f"目前{level_lst[job]}共有{staff_count}人：")
            for staff in staff_lst:
                print(f"{staff.uid} - {staff.name}")

    def search(self):
        choice = input("1.员工查询;2.职位查询：")
        if choice == "1":
            self.staff_search()
        elif choice == "2":
            self.job_search()
        else:
            print("查询类型输入错误！")
            return
        
    def level_up(self):
        while True:
            try:
                uid = int(input("请输入工号："))
                break
            except ValueError:
                print("请输入正确的数字！")
        
        found = False
        for staff in self.staffs:
            if staff.get_uid() == uid:
                print(f"{staff.get_name()}，工号：{staff.get_uid()}，当前职位：{staff.get_level()}，当前薪资：{staff.get_salary()}")
                found = True
                break
        if not found:
            print("该工号不存在！")
            return
        
        while True:
            try:
                increase_level = int(input("请输入需要增加的级数："))
                if increase_level < 1:
                    print("增加级数必须大于0！")
                    continue
                break
            except ValueError:
                print("请输入正确的数字！")
        
        job_grade_max = {"E": 10, "T": 6, "M": 3}
        current_job = staff.get_job()
        current_grade = staff.get_grade()
        new_grade = current_grade + increase_level
        
        if new_grade <= job_grade_max[current_job]:
            staff.grade = new_grade
            print(f"升级成功！")
            print(f"{staff.get_name()}，工号：{staff.get_uid()}，升级后职位：{staff.get_level()}，升级后薪资：{staff.get_salary()}")
        else:
            if current_job == "M":
                print("已经是最高职位，无法继续升职！")
                return
            if current_job == "E":
                new_staff = Teamleader(staff.uid)
            else:
                new_staff = Manager(staff.uid)
            new_staff.name = staff.get_name()
            new_staff.year = staff.get_year()
            new_staff.grade = 1
            old_salary = staff.get_salary()
            new_salary = new_staff.get_salary()
            change = new_salary - old_salary
            idx = self.staffs.index(staff)
            self.staffs[idx] = new_staff
            print("升级成功！")
            print(f"{new_staff.name}，工号：{new_staff.uid}，升级后职位：{new_staff.get_level()}，升级后薪资：{new_salary}({change:+.0f})")

    def level_down(self):
        while True:
            try:
                uid = int(input("请输入工号："))
                break
            except ValueError:
                print("请输入正确的数字！")
        
        found = False
        for staff in self.staffs:
            if staff.get_uid() == uid:
                print(f"{staff.get_name()}，工号：{staff.get_uid()}，当前职位：{staff.get_level()}，当前薪资：{staff.get_salary()}")
                found = True
                break
        if not found:
            print("该工号不存在！")
            return
        
        while True:
            try:
                demote_level = int(input("请输入需要减少的级数："))
                if demote_level < 1:
                    print("减少级数必须大于0！")
                    continue
                break
            except ValueError:
                print("请输入正确的数字！")
        
        job_grade_max = {"E": 10, "T": 6, "M": 3}
        current_job = staff.get_job()
        current_grade = staff.get_grade()
        new_grade = current_grade - demote_level
        
        if new_grade >= 1:
            staff.grade = new_grade
            print("降级成功！")
            print(f"{staff.get_name()}，工号：{staff.get_uid()}，降级后职位：{staff.get_level()}，降级后薪资：{staff.get_salary()}")
        else:
            if current_job == "E":
                print("已经是最低职位，无法继续降职！")
                return
            if current_job == "T":
                new_staff = Employee(staff.uid)
            else:
                new_staff = Teamleader(staff.uid)
            new_staff.name = staff.get_name()
            new_staff.year = staff.get_year()
            new_staff.grade = job_grade_max[new_staff.job]
            old_salary = staff.get_salary()
            new_salary = new_staff.get_salary()
            change = new_salary - old_salary
            idx = self.staffs.index(staff)
            self.staffs[idx] = new_staff
            print("降级成功！")
            print(f"{new_staff.name}，工号：{new_staff.uid}，升级后职位：{new_staff.get_level()}，升级后薪资：{new_salary}({change:+.0f})")

def main():
    manage = Management()
    while True:
        print("1.录入;2.查询;3.升级;4.降级;5.退出：")
        choice = input("请输入您的选择：")
        if choice == "1":
            manage.add_staff()
        elif choice == "2":
            manage.search()
        elif choice == "3":
            manage.level_up()
        elif choice == "4":
            manage.level_down()
        elif choice == "5":
            print("谢谢使用！")
            break
        else:
            print("选择输入错误！")

Raizertapissic

请回复您的答案^_^

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

第 0 题的答案是：多态 = 同一个方法，不同对象不同表现

第 1 题的答案是：代码更简洁，更容易扩展

第 2 题的答案是：是

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

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

第 5 题的答案是：不是

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

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

铭记太阳

0
同一个运算符、函数，面对不同对象有不同的作用效果
1
1.提高代码的灵活性和可扩展性
2.实现“鸭子类型”
3.代码简洁，不用写大量的判断语句来判断对象的类型
4.接口统一，降低学习成本

2
算多态

3
如果它走起来像鸭子，叫起来也像鸭子，那它就是鸭子

4
降低了耦合

5
不是

动动脚，现在已经不能这么叫了，每次题都得拼尽全力
0
不过上上节跟着敲了一个grok，上节自己又自创了一个超市，现在会写这种模块化编程了，在检测地方额外加入mixin函数
不是，这工资有问题啊老板，E10是3000+500*10,升级后T1 4000 + 800*1
什么明争暗斗，明升实降
这一次是真的独立完成的，呱唧呱唧呱唧

class Yuangong:
    def __init__(self,uid,name,job,grade,year):
        self.uid = uid
        self.name = name
        self.job = job
        
        self.grade = grade
        self.year = year
        #self.salary = 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):
        n = self.get_job()
        if n == 'E':
            return 3000 + 500*self.get_grade() + 50*self.get_year()
        elif n == 'T':
            return 4000 + 800*self.get_grade() + 100*self.get_year()
        elif n == 'M':
            return 5000 + 1000*(self.get_grade()+self.get_year())

class CheckMixin:
    def Job_check(self,job):
        while (job != 'E') and (job != 'T') and (job != 'M'):
            job = input('输入错误，请重新输入职位：E T M')
        return job
    def Grade_check(self,grade,job):
        while job == 'E' and (grade<1 or grade >10):
            grade= int(input('该级别最高为10，请重新输入级别'))
        while job == 'T' and (grade<1 or grade >6):
            grade= int(input('该级别最高为6，请重新输入级别'))
        while job == 'M' and (grade<1 or grade >3):
            grade= int(input('该级别最高为3，请重新输入级别'))
        return grade
   
class Management(CheckMixin):

    database=[]
    ChuShi_uid = 10000
    def welcome(self):
        order = int(input('1录入 2查询 3升级 4降级 5退出'))
        while order != 5:
            if order == 1:
                self.database.append(self.Luru())
            elif order == 2:
                self.Chaxun()
            elif order == 3:
                self.Shengji()
            elif order == 4:
                self.Jiangji()
               
            order = int(input('1录入 2查询 3升级 4降级 5退出'))
        
    def Luru(self):
        uid = self.ChuShi_uid
        self.ChuShi_uid += 1
        name = input('姓名')
        job = input('职位：E T M')
        job = self.Job_check(job)

        grade= int(input('级别'))
        grade = self.Grade_check(grade,job)
        
        year = int(input('工龄'))
        return Yuangong(uid,name,job,grade,year)

    def Chaxun(self):
        order = int(input('1员工查询 2职位查询'))
        if order == 1:
            uid = int(input('请输入工号'))
            for i in self.database:
                if i.get_uid() == uid:
                    print(f'姓名{i.get_name()}\n职位{i.get_job()}')
                    print(f'级别{i.get_grade()}\n工龄{i.get_year()}\n薪资{i.salary()}')
                    break
            else:
                print('该工号不存在')
        elif order == 2:
            job = input('请输入要查询的职位E T M')
            job = self.Job_check(job)
            renshu = 0
            for i in self.database:
                if i.get_job() == job:
                    print(f'{i.get_uid()} - {i.get_name()}')
                    renshu += 1
            print(f'目前{job}共有{renshu}人')

    def Shengji(self):
        uid = int(input('请输入工号'))
        for i in self.database:
            if i.get_uid() == uid:
                    break
        else:
                print('该工号不存在')
        salary = i.salary()
        print(f'{i.get_name()} 工号{i.get_uid()},职位{i.get_job()}{i.get_grade()},薪资{salary}')
        lvlup = int(input('请输入增加的级数'))
        i.grade += lvlup
        if i.job == 'E' and i.grade > 10:
            i.job = 'T'
            i.grade = 1
        elif i.job == 'T' and i.grade > 6:
            i.job = 'M'
            i.grade = 1
        elif i.job == 'M' and i.grade >3:
            print('升级不能超过极限，最高等级为M3')
            i.grade = 3
        new_salary = i.salary()
        print(f'{i.get_name()} 工号{i.get_uid()},'
             f'升级后职位{i.get_job()}{i.get_grade()},薪资{new_salary}({(new_salary-salary):+})')
        
    def Jiangji(self):
        uid = int(input('请输入工号'))
        for i in self.database:
            if i.get_uid() == uid:
                    break
        else:
                print('该工号不存在')
        salary = i.salary()
        print(f'{i.get_name()} 工号{i.get_uid()},职位{i.get_job()}{i.get_grade()},薪资{salary}')
        lvldown = int(input('请输入降低的级数'))
        i.grade -= lvldown
        if i.job == 'E' and i.grade < 1:
            print('不能再降低了，老板')
            i.grade = 1
        elif i.job == 'T' and i.grade < 1:
            i.job = 'E'
            i.grade = 10
        elif i.job == 'M' and i.grade <1:
            i.job = 'T'
            i.grade = 6
        new_salary = i.salary()
        print(f'{i.get_name()} 工号{i.get_uid()},'
             f'降级后职位{i.get_job()}{i.get_grade()},薪资{new_salary}({(new_salary-salary):+})')
        
m = Management()
m.welcome()

困在雨天里

请回复您的答案^_^

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

第 0 题的答案是：通过方法重写和鸭子类型

第 1 题的答案是：提高灵活性

第 2 题的答案是：可以，运算符多态

第 3 题的答案是：如果他走起来像鸭子。。。。。

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

第 5 题的答案是：不

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

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

261329663

请回复您的答案^_^答案

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

深津冥夜

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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