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

zhjw0612

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

看答案

小豆壳儿

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

夏季的春秋

请回复您的答案^_^
0、一个对象可以调用方法不同的用处
1、一个函数实现多个功能
2、可以
3、
4、增强了内聚
5、不是
-------- 问答题 --------

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

learner95

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

剑来龙族悍刀行

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

璨璨呀

请回复您的答案^_^

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

第 0 题的答案是：面对不同对象，一些函数的作用不同

第 1 题的答案是：

第 2 题的答案是：可以

第 3 题的答案是：

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

第 5 题的答案是：属于

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

请将第 0 题的代码写在下方：
class Information:
   
    def __init__(self):
        self.names = []
        self.uids = []
        self.jobs = []
        self.grades = []
        self.years = []
    def get_name(self,name):
        self.names.append(name)
    def get_uid(self,uid):  #工号
        self.uids.append(uid)
    def get_job(self,job):  #职位
        self.jobs.append(job)
    def get_grade(self,grade):  #级别
        self.grades.append(grade)
    def get_year(self,year):  #工龄
        self.years.append(year)
    def salary(self,name):
        i = self.names.index(name)
        g = int(self.grades[i])
        j = self.jobs[i]
        y = int(self.years[i])
        if j == 'E':
            s = 3000 + 500*g + 50*y
        elif j == 'T':
            s = 4000 + 800*g + 100*y
        elif j == 'M':
            s = 5000 + 1000*(g+y)
        return s

class Check(Information):
    def check_grade(self,job,grade):
        grade = int(grade)
        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 check_employee(self,u):
        if self.uids.count(u) == 0:
            print('该工号不存在！')
        else:
            i = self.uids.index(u)
            return i
    def check_job(self,j):
        if j == 'E':
            job = '普通员工'
        elif j == 'T':
            job = '组长'
        elif j == 'M':
            job = '经理'
        num = self.jobs.count(j)
        if num == 0:
            print(f'目前公司没有{job}')
        else:
            return job,num
            
   

class Function(Check,Information):
    def Input(self):
        name = input('姓名：')
        super().get_name(name)
        job = input('职位（E.普通员工；T.组长；M.经理）：')
        super().get_job(job)
        year = input('工龄：')
        super().get_year(year)
        grade = input('级别：')
        grade = super().check_grade(job,grade)
        super().get_grade(grade)
        uid = 10000+len(self.names)-1
        super().get_uid(uid)
        s = super().salary(name)
        print(f'录入成功！姓名：{name}，工号：{uid}，薪资：{s}')
    def Inquiry(self):
        number = input('1.员工查询；2.职位查询：')
        if number == '1':
            u = int(input('请输入工号：'))
            i = super().check_employee(u)
            print(f'姓名：{self.names[i]}\n职位：{self.jobs[i]}')
            print(f'级别：{self.grades[i]}\n工龄：{self.years[i]}')
            print(f'薪资：{super().salary(self.names[i])}')
        if number == '2':
            j = input('职位（E.普通员工；T.组长；M.经理）：')
            job,num = super().check_job(j)
            print(f'目前{job}共有{num}人：')
            for k in range(len(self.names)):
                if self.jobs[k] == j:
                    print(f'{self.uids[k]} - {self.names[k]}')
    def upgrade(self):
        u = int(input('请输入工号：'))
        i = super().check_employee(u)
        n = self.names[i]
        j = self.jobs[i]
        g = self.grades[i]
        s = super().salary(self.names[i])
        print(f'{n},工号：{self.uids[i]}，当前职位：{j}{g},当前薪资：{s}')
        add = int(input('请输入需要增加的级数：'))
        g += add
        if j == 'E' and g>10:
            self.jobs[i] = 'T'
            self.grades[i] = 1
        elif j == 'T' and g>6:
            self.jobs[i] = 'M'
            self.grades[i] = 1
        else:
            self.grades[i] = g
        print('升级成功！')
        s = super().salary(self.names[i])
        print(f'{n},工号：{self.uids[i]}，当前职位：{self.jobs[i]}{self.grades[i]},当前薪资：{s}')

lovcpp

请回复您的答案^_^

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

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

第 1 题的答案是：对不同的对象采取不同的操作

第 2 题的答案是：可以

第 3 题的答案是：

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

第 5 题的答案是：不是

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

请将第 0 题的代码写在下方：
class Member:
    def __init__(self,uid,name,job,year,grade):
        self.uid=uid
        self.name=name
        self.job=job
        self.year=year
        self.grade=grade
class Employee(Member):
    def __init__(self, uid, name, job, year, grade):
        super().__init__(uid, name, job, year, grade)
        while self.grade>10:
            self.grade=int(input('该职位最高级别为10,请重新录入级别:'))
    def salary(self):
        return 3000+500*self.grade+50*self.year
class Teamleader(Member):
    def __init__(self,uid, name, job, year, grade):
        super().__init__(uid, name, job, year, grade)
        while self.grade>6:
            self.grade=int(input('该职位最高级别为6,请重新录入级别:'))
    def salary(self):
        return 4000+800*self.grade+100*self.year
class Manager(Member):
    def __init__(self, uid, name, job, year, grade):
        super().__init__(uid, name, job, year, grade)
        while self.grade>3:
            self.grade=int(input('该职位最高级别为3,请重新录入级别:'))
    def salary(self):
        return 5000+1000*self.grade+1000*self.year

class Manage:
    def __init__(self):
        self.code=10000
        self.member={}
    def operate(self):
        order=int(input('1.录入；2.查询；3.升级；4.降级；5.退出'))
        while not order==5:
            if order==1:
                self.creat_member()
            if order==2:
                self.view()
            if order==3:
                self.upgrade()
            if order==4:
                self.demote()
            order = int(input('1.录入；2.查询；3.升级；4.降级；5.退出'))
    def entering(self,uid,name,job,year,grade):
        if job=='E':
            self.member[uid]=Employee(uid,name,job,year,grade)
        elif job=='T':
            self.member[uid]=Teamleader(uid,name,job,year,grade)
        elif job=='M':
            self.member[uid]=Manager(uid,name,job,year,grade)
    def creat_member(self):
        name=input('姓名：')
        uid=self.code
        self.code+=1
        job=input('职位（E.普通员工；T.组长；M.经理）：')
        year=int(input('工龄：'))
        grade=int(input('级别:'))
        self.entering(uid,name,job,year,grade)
        print(f'录入成功！姓名：{name},工号：{uid},薪资：{self.member[uid].salary()}')
    def view(self):
        order=input('1.员工查询；2.职位查询：')
        if order=='1':
            num=int(input('请输入工号：'))
            if num in self.member:
                print(f'姓名：{self.member[num].name}')
                print(f'职位：{self.member[num].job}')
                print(f'级别：{self.member[num].grade}')
                print(f'工龄：{self.member[num].year}')
                print(f'薪资：{self.member[num].salary()}')
            else:
                print('该员工号不存在!')
        elif order=='2':
            job=input('职位（E.普通员工；T.组长；M.经理）：')
            count=0
            l=[]
            for each in self.member:
                if self.member[each].job==job:
                    count+=1
                    l.append(each)
            if job=='E':
                jobname='普通员工'
            elif job=='T':
                jobname = '组长'
            elif job=='M':
                jobname='经理'
            if count>0:
                print(f'目前{jobname}共有{count}人')
                for each in l:
                    print(f'{each}-{self.member[each].name}')
            else:
                print(f'目前公司没有{jobname}!')
    def upgrade(self):
        num=int(input('请输入工号：'))
        if num in self.member:
            name=self.member[num].name
            job=self.member[num].job
            grade=self.member[num].grade
            year=self.member[num].year
            salary_old=self.member[num].salary()
            print(f'{name},工号：{num},当前职位：{job}{grade}，当前薪资：{salary_old}')
            self.member.pop(num)
            grade_up=int(input('请输入需要增加的级数：'))
            grade+=grade_up
            if job=='E' and grade>10:
                job='T'
                grade=1
            elif job=='T' and grade>6:
                job='M'
                grade=1
            elif job=='M' and grade>3:
                print('经理最高职级为3级！')
                grade-=grade_up
            self.entering(num, name, job, year, grade)
            salary_new = self.member[num].salary()
            print('升级成功！')
            print(f'{name},工号：{num},升级后职位：{job}{grade}，升级后薪资：{salary_new}(+{salary_new-salary_old})')
        else:
            print('该员工号不存在!')
    def demote(self):
        num = int(input('请输入工号：'))
        if num in self.member:
            name = self.member[num].name
            job = self.member[num].job
            grade = self.member[num].grade
            year = self.member[num].year
            salary_old = self.member[num].salary()
            print(f'{name},工号：{num},当前职位：{job}{grade}，当前薪资：{salary_old}')
            self.member.pop(num)
            grade_de = int(input('请输入需要减少的级数：'))
            grade -= grade_de

            if job == 'T' and grade <0:
                job = 'M'
                grade = 10
            elif job == 'M' and grade <0:
                job = 'T'
                grade = 6
            elif job == 'E' and grade < 0:
                print('无法降级！')
                grade -= grade_de
            self.entering(num, name, job, year, grade)
            salary_new = self.member[num].salary()
            print('降级成功！')
            print(f'{name},工号：{num},降级后职位：{job}{grade}，降级后薪资：{salary_new}({salary_new - salary_old})')
        else:
            print('该员工号不存在!')
m=Manage()
m.operate()

who-fox

0001

hehedawang

see

dragoncwh

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

小黑屋1024

0.
通过操作符、函数参数、对象的方式实现多态的。
1.相同的函数、操作符，通过输入不同类型的对象，从而得到不同类型的效果。
2.可以
3.
4.增强了内聚，但是增加了耦合
5.不是

bk2020113458

查看答案

kkk1029

ss请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

Superfreak

请回复您的答案^_^

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

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