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

SharlkHomes

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

海岸线烧烤

请回复您的答案^_^

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

第 0 题的答案是：
面对不同类型的对象时不显式地判断对象的类型但是完成相同或相似的效果
第 1 题的答案是：
灵活
第 2 题的答案是：
可以
第 3 题的答案是：
会飞会跑的就是鸭子，哪怕它不是鸭子（不同的类如果有同名的方法，就是鸭子类型）
第 4 题的答案是：
降低了耦合度
第 5 题的答案是：
不属于
-------- 动动手 --------

请将第 0 题的代码写在下方：
LEVEL_SEQ = {'E':[1,2,3,4,5,6,7,8,9,10],'T':[1,2,3,4,5,6],'M':[1,2,3]}
current_uid = 10000
staff = []

class People:
    __slots__ = ['_name','_job','_grade','_year','_uid']
   
    def __init__(self):
        self._name = input("姓名：")
        self._job = input("职位（E.普通员工；T.组长；M.经理）：")
        
        while True: #确保级别输入正确
            self._grade = int(input("级别："))
            if self._grade > LEVEL_SEQ[self._job][-1]:
                self._grade = input(f"级别输入错误，{self._job}级别最高为{LEVEL_SEQ[self._job][-1]}级，请重新输入级别：")
            else:
                break

        self._year =  int(input("工龄："))
        global current_uid
        self._uid = current_uid
        current_uid += 1
   
    def get_uid(self):
        return f"工号：{self._uid}"
   
    def get_name(self):
        return f"名字：{self._name}"

    def get_job(self):
        return f"职位：{self._job}"
   
    def get_grade(self):
        return f"级别：{self._grade}"
   
    def get_year(self):
        return f"工龄：{self._year}"

    def salary(self):
        if self._job == 'E':
            return 3000 + int(self._grade) * 500 + int(self._year) * 50
        elif self._job == 'T':
            return 4000 + int(self._grade) * 800 + int(self._year) * 100
        elif self._job == 'M':
            return 5000 + int(self._grade) * 1000 + int(self._year) * 1000

while True:
    i = int(input("1.录入；2.查询；3.升级；4.降级；5.退出"))
    if i == 5:
        break
    elif i == 1:
        staff.append(People())
        print(f"录入成功！姓名：{staff[-1]._name}，工号：{staff[-1]._uid}，薪资：{staff[-1].salary()}")
    elif i == 3:
        inquiry_id = int(input("请输入工号："))
        
        

        

Epylus

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

神探伽利略

1

lumber2388779

请回复您的答案^_^

-----

苏小灭

请回复您的答案^_^

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

第 0 题的答案是：同一个函数根据不同的参数返回不同的结果

第 1 题的答案是：调用时不需要区分对象

第 2 题的答案是：可以

第 3 题的答案是：不知道

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

第 5 题的答案是：不是

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

请将第 0 题的代码写在下方：
#普通员工类
class Employee:
    def __init__(self,name,job,grade,year,uid):
        self.name=name
        self.job=job
        self.grade=grade
        self.year=year
        self.uid=uid

    def get_uid(self):
        return self.uid
    def get_name(self):
        return self.name
    def get_job(self):
        return self.job
    def get_grade(self):
        return self.grade
    def get_year(self):
        return self.year
    def get_salary(self):
        return 3000+500*self.get_grade()+50*self.get_year()

#组长类
class Teamleader(Employee):
    def get_salary(self):
        return 4000+800*self.get_grade()+100*self.get_year()

#经理类
class Manager(Employee):
    def get_salary(self):
        return 5000+1000*(self.get_grade()+self.get_year())

#功能组件
class EmployeeMixin:
    #检查工号
    def is_exist(self,employees):
        uid=int(input("请输入工号："))
        if employees.get(uid):
            return uid
        else:
            return False
   
    #职位对应的最高级别
    def grade_total(self,job):
        if job=='E':
            maxlevel=10
        if job=='T':
            maxlevel=6
        if job=='M':
            maxlevel=3
        return maxlevel

    #统计不同职位员工
    def type_count(self,employees):
        counts=0
        result={}
        job=input("职位（E.普通员工;T.组长;M.经理）：")
        t={'E':'普通员工','T':'组长','M':'经理'}
        for k,v in employees.items():
            if v.job==job:
                counts+=1
                result[k]=v
        if counts==0:
            print(f"目前公司没有{t[job]}！")
        else:
            print(f"目前{t[job]}共有 {counts} 人:")
        return result      
        
class Admin(EmployeeMixin):
    def __init__(self):
        self.employees={}
        self.uid=10000
        
    def welcome(self):
        ins=0
        while ins!='5':
            ins=input("1.录入；2.查询；3.升级；4.降级；5.退出：")
            if ins=='1':
                self.add()
            if ins=='2':
                self.view()
            if ins=='3':
                self.upgrade()
            if ins=='4':
                self.demote()

    #实例化不同类型的员工
    def employee_type(self,name,job,grade,year,uid):
        if job=='E':
            return Employee(name,job,grade,year,uid)
        if job=='T':
            return Teamleader(name,job,grade,year,uid)
        if job=='M':
            return Manager(name,job,grade,year,uid)

    #程序功能：信息录入
    def add(self):
        name=input("姓名：")
        job=input("职位（E.普通员工;T.组长;M.经理）：")
        year=int(input("工龄："))
        grade=int(input("级别："))
        maxlevel=self.grade_total(job)
        while grade>maxlevel:
            grade=int(input(f"该职位为高级别为{maxlevel}，请重新录入级别："))
        employee=self.employee_type(name,job,grade,year,self.uid)
        self.employees[self.uid]=employee
        print(f"录入成功！姓名：{name}，工号：{self.uid}，薪资：{self.employees[self.uid].get_salary()}\n")
        self.uid+=1

    #程序功能：查询
    def view(self):
        t=input("1.员工查询;2.职位查询：")
        if t=='1':
            uid=self.is_exist(self.employees)
            if uid:
                print("姓名：",self.employees[uid].get_name())
                print("职位：",self.employees[uid].get_job())
                print("级别：",self.employees[uid].get_grade())
                print("工龄：",self.employees[uid].get_year())
                print("薪资：",self.employees[uid].get_salary())
                print()
            else:
                print("该工号不存在！\n")
        if t=='2':
            people=self.type_count(self.employees)
            for k,v in people.items():
                print(f"{k} - {v.name}")
            print()

    #程序功能：升级
    def upgrade(self):
        m=['E','T','M']
        uid=self.is_exist(self.employees)
        if uid:
            name=self.employees[uid].get_name()
            job=self.employees[uid].get_job()
            grade=self.employees[uid].get_grade()
            year=self.employees[uid].get_year()
            salary=self.employees[uid].get_salary()
            print(f"{name}，工号：{uid}，当前职位：{job}{grade}，当前薪资：{salary}")
            t=int(input("请输入需要增加的级数："))
            maxlevel=self.grade_total(job)
            if grade+t>maxlevel:
                i=m.index(job)
                if i!=len(m)-1:
                    job=m[i+1]
                    grade=1
                    employee=self.employee_type(name,job,grade,year,uid)
                    self.employees[uid]=employee
                    print("升级成功！")
                    new_salary=self.employees[uid].get_salary()
                    print(f"{name}，工号：{uid}，升级后职位：{job}{grade}，升级后薪资：{new_salary}(+{new_salary-salary})\n")
                else:
                    grade=maxlevel
                    self.employees[uid].grade=grade
                    print("已是最高级别！\n")
                    print(f"{name}，工号：{uid}，增加级数后职位：{job}{grade}")
            else:
                self.employees[uid].grade=grade
                print("未升级\n")
                print(f"{name}，工号：{uid}，增加级数后职位：{job}{grade}")
        else:
            print("该工号不存在！\n")

    #程序功能：降级
    def demote(self):
        m=['E','T','M']
        uid=self.is_exist(self.employees)
        if uid:
            name=self.employees[uid].get_name()
            job=self.employees[uid].get_job()
            grade=self.employees[uid].get_grade()
            year=self.employees[uid].get_year()
            salary=self.employees[uid].get_salary()
            print(f"{name}，工号：{uid}，当前职位：{job}{grade}，当前薪资：{salary}")
            t=int(input("请输入需要减少的级数："))
            if grade-t<=0:
                i=m.index(job)
                if i!=0:
                    job=m[i-1]
                    grade=self.grade_total(job)
                    employee=self.employee_type(name,job,grade,year,uid)
                    self.employees[uid]=employee
                    print("降级成功！")
                    new_salary=self.employees[uid].get_salary()
                    print(f"{name}，工号：{uid}，降级后职位：{job}{grade}，升级后薪资：{new_salary}({new_salary-salary})\n")
                else:
                    grade=1
                    self.employees[uid].grade=grade
                    print("已是最低级别！\n")
                    print(f"{name}，工号：{uid}，减少级数后职位：{job}{grade-t}")
            else:
                self.employees[uid].grade=grade-t
                print("未降级\n")
                print(f"{name}，工号：{uid}，减少级数后职位：{job}{grade-t}")
        else:
            print("该工号不存在！\n")
            
        

def main():
    a=Admin()
    a.welcome()

走走看看笑笑

请回复您的答案^_^

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

第 0 题的答案是：
调用相同函数，创建不同对象
第 1 题的答案是：
减少重复代码
第 2 题的答案是：
可以
第 3 题的答案是：

第 4 题的答案是：
增强了内聚
第 5 题的答案是：
不属于
-------- 动动手 --------

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

够用就行阿嚏

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

Piera

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：
可以
第 3 题的答案是：
如果它看起来像鸭子，游起来像鸭子，那么它就是鸭子
第 4 题的答案是：
降低耦合度
第 5 题的答案是：
是
-------- 动动手 --------

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

我叫玮哥强

请回复您的答案^_^

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

第 0 题的答案是：1

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

沐熙清

请回复您的答案^_^

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

第 0 题的答案是：根据对象输出不同结果

第 1 题的答案是：个性化

第 2 题的答案是：可以

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

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

第 5 题的答案是：不属于

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

请将第 0 题的代码写在下方：
class Member:
    def __init__(self, name, job, grade, year, uid):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
        self.uid = uid


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

#员工方法
    def salary(self, job):
        
        

#员工录入
    def create_member(self):
        name = input('姓名: ')
        job = input('职位 (E.普通员工;T.组长;M.经理) : ')
        year = int(input('工龄: '))
        grade = int(input('级别: '))
        member = Member(name, job, grade, year, self.uid)
        self.members[self.uid] = member

一氧化二氢_

请回复您的答案^_^

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

第 0 题的答案是：从基础的+和*，再到类

第 1 题的答案是：可以实现不同类型的运算

第 2 题的答案是：可以

第 3 题的答案是：不知道

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

第 5 题的答案是：不属于

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

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

ruidun

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

liujiezheng

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

1010025290

请回复您的答案^_^

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

第 0 题的答案是：  不用关心对象的具体类型，只关心对象是否有相同方法 就可以用同一的接口进行调用
第 1 题的答案是： 不用关心对象的具体类型，只关心对象是否有相同方法 就可以用同一的接口进行调用
第 2 题的答案是：不可以 一个是运算的方法 一个是累加的方法

第 3 题的答案是：不到啊

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

第 5 题的答案是：不属于

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

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

EASEAS

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

mtcy123

请回复您的答案^_^

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

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

EL-DLG

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

请将第 0 题的代码写在下方：class Member:
    def __init__(self,name,job,grade,year,uid):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year
        self.uid = uid
            
class Manage:
    def __init__(self):
        self.members = {}
        self.uid = 10000

    def create_member(self):
        uid = self.get_uid()
        name = self.get_name()
        job = self.get_job()
        year = self.get_year()
        grade = self.get_grade(job)
        self.members[uid] = Member(name,job,grade,year,uid)
        print(f"录入成功！姓名：{name},工号：{uid}，薪资{self.salary(uid)}")
        
    def query(self):
        ins = 0
        while ins not in ('1','2'):
            ins = input("1.员工查询;2.职位查询：")
            
        if ins == '1':
            self.employee_query()
        if ins == '2':
            self.position_query()
            
    def employee_query(self):
        uid = self.confirm()
        if uid:
                print(f"""
姓名：{self.members[uid].name}
职位：{self.members[uid].job}
级别：{self.members[uid].grade}
工龄：{self.members[uid].year}
薪资：{self.salary(uid)}
""".strip('\n'))
               
    def position_query(self):
        job = self.get_job()
        text = [f"{n.uid} - {n.name}" for n in self.members.values() if n.job == job]
        k = {'E':"普通员工",'T':"组长",'M':"经理"}
        if len(text):
            print(f"目前{k[job]}共有{len(text)}人：\n{"\n".join(text)}")
        else:
            print(f"目前公司没有{k[job]}!")
            
    def upgrade(self):
        text = {'E':10 ,'T':6 ,'M':3 }
        uid = self.confirm()
        if not uid:
            return None
        ord_salary = self.salary(uid)
        print(f"{self.members[uid].name}，工号：{uid}，当前职位：{self.members[uid].job}{self.members[uid].grade}，当前薪资：{self.salary(uid)}")
        level_up = int(input("请输入需要增加的级数："))
        level = self.members[uid].grade + level_up
        if level <= text[self.members[uid].job]:
            self.members[uid].grade = level
        elif level > text[self.members[uid].job] and self.members[uid].job != 'M':
            self.members[uid].grade = 1
            if self.members[uid].job == 'E':
                self.members[uid].job = 'T'
            if self.members[uid].job == 'T':
                self.members[uid].job = 'M'
        else:
            print("等级数据异常，升级失败")
            return None
        print(f"{self.members[uid].name}，工号：{uid}，升级后职位：{self.members[uid].job}{self.members[uid].grade}，升级后薪资：{self.salary(uid)}(+{self.salary(uid) - ord_salary})")

    def downgrade(self):
        text = {'E':10 ,'T':6 ,'M':3 }
        uid = self.confirm()
        if not uid:
            return None
        ord_salary = self.salary(uid)
        print(f"{self.members[uid].name}，工号：{uid}，当前职位：{self.members[uid].job}{self.members[uid].grade}，当前薪资：{self.salary(uid)}")
        level_down = int(input("请输入需要减少的级数："))
        level = self.members[uid].grade - level_down
        if level > 0:
            self.members[uid].grade = level
        elif level <= 0 and self.members[uid].job != 'E':
            if self.members[uid].job == 'T':
                self.members[uid].job = 'E'
            if self.members[uid].job == 'M':
                self.members[uid].job = 'T'
            self.members[uid].grade = text[self.members[uid].job]
        else:
            print("等级数据异常，降级失败")
            return None
        print(f"{self.members[uid].name}，工号：{uid}，降级后职位：{self.members[uid].job}{self.members[uid].grade}，降级后薪资：{self.salary(uid)}(-{ord_salary - self.salary(uid)})")

    def confirm(self):
        uid = int(input("请输入工号："))
        if self.members.get(uid):
            return uid
        else :
            print("该工号不存在!")
            
    def get_uid(self):
        uid = self.uid
        self.uid += 1
        return uid
   
    def get_name(self):
        name = input("姓名：")
        return name
   
    def get_job(self):
        job = input("职位（E.普通员工;T.组长;M.经理）：")
        while job not in ('E','T','M'):
            job = input("请输入正确的职位符号：")
        return job
        
    def get_grade(self,job):
        text = {'E':10 ,'T':6 ,'M':3 }
        max_grade = text[job]
        grade = int(input("级别："))
        while not 1 <= grade <= max_grade:
                grade = int(input(f"该职位最高级别为{max_grade}，请重新录入级别："))
        return grade
   
    def get_year(self):
        while True:
            try:
                year = int(input("工龄："))
                if year < 0:
                    raise ValueError
            except ValueError:
               print("请输入正整数")
            else:
                return year
   
    def salary(self,uid):
        text = {'E':3000 + 500 * self.members[uid].grade + 50 * self.members[uid].year,
                'T':4000 + 800 * self.members[uid].grade + 100 * self.members[uid].year,
                'M':5000 + 1000 * (self.members[uid].grade + self.members[uid].year)}
        return text[self.members[uid].job]
        
    def welcome(self):
        ins = 0
        while ins != '5':
            ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
            if ins == '1':
                self.create_member()
            if ins == '2':
                self.query()
            if ins == '3':
                self.upgrade()
            if ins == '4':
                self.downgrade()
   
def main():
    m = Manage()
    m.welcome()
main()

余宏伟

请回复您的答案^_^

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

第 0 题的答案是：继承和重写

第 1 题的答案是：可扩展性，代码重用，简化复杂性，提高可读性和可维护性

第 2 题的答案是：不能

第 3 题的答案是：看它走起路来像鸭子、叫起来像鸭子，那么它就是鸭子

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

第 5 题的答案是：不属于

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

请将第 0 题的代码写在下方：
class Staff:
    name = ""
    job = ""
    grade = 0
    year = 0
    uid = 10000
    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 set_uid(self):
        self.uid += 1
    def salary(self):
        pass
    def promote(steps):
        pass
    def demote(steps):
        pass
class Employee(Staff):
    def __init__(self, name, job, grade, year, uid):
        super().__init__(name, job, grade, year, uid)
        
    def salary(self):
        return 3000 + 500 * self.grade + 50 * self.year
    def promote(self, steps):
        self.grade += steps
        if self.grade > 10:
            self.job = "TeamLeader"
            self.grade = 1
        print(f"{self.get_name()} promoted to grade {self.get_grade()}")
   
class Teamleader(Staff):
    def __init__(self, name, job, grade, year, uid):
        super().__init__(name, job, grade, year, uid)
        
    def salary(self):
        return 4000 + 800 * self.grade + 100 * self.year
    def promote(self, steps):
        self.grade += steps
        if self.grade > 6:
            self.job = "Manager"
            self.grade = 1
        print(f"{self.get_name()} promoted to grade {self.get_grade()}")
    def demote(self, steps):
        self.grade -= steps
        if self.grade < 1:
            self.job = "Employee"
            self.grade = 10
        print(f"{self.get_name()} demoted to grade {self.get_grade()}")


class Manager(Staff):
    def __init__(self, name, job, grade, year, uid):
        super().__init__(name, job, grade, year, uid)
        
    def salary(self):
        return 5000 + 1000 * (self.grade + self.year)
    def demote(self, steps):
        self.grade -= steps
        if self.grade < 1:
            self.job = "TeamLeader"
            self.grade = 6
        print(f"{self.get_name()} demoted to grade {self.get_grade()}")
class Manage:
    def __init__(self):
        self.staff = []

    def add_staff(self, staff):
        self.staff.append(staff)

    def welcome(self):
        self.staff = []
        self.uid = 10000
        print("Welcome to the Staff Management System")
        for member in self.staff:
            print(f"Name: {member.get_name()}, Job: {member.get_job()}, Salary: {member.salary()}")
def main():
    m = Manage()
    m.welcome()

EL-DLG

请回复您的答案^_^

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

第 0 题的答案是：体现在鸭子类型，不关心是什么，只关心能干什么

第 1 题的答案是：提高代码的可扩展性和可维护性

第 2 题的答案是：可以

第 3 题的答案是：如果它看起来像鸭子，游泳像鸭子，叫声像鸭子，那么它很可能就是鸭子

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

第 5 题的答案是：是

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

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