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

ariiczhang

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

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、不是

Kksaint

0，通过类的方法
1，可以在不判断类型的情况下直接使用方法
2，可以
3，
4，增加了内聚
5，属于

0，

ojb616

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、不是

wshiming123

1

Hazalea

问答题：
0. Python 是如何体现面向对象的多态特性的？
通过重写的方式，重写了类的方法。

1. 多态的优势是什么？
在不影响类的属性的基础上，可以重新修改类的方法。

2. 请问在 Python 中，1+1 == 2 跟 '1' + '1' == '11'，这种根据操作数类型不同，得到不同结果的现象，可以称为多态吗？
可以

3. 关于鸭子类型这个名字的来源，有一句谚语，你知道是什么吗？
一只鸟长得像鸭子，叫声像鸭子，走路也像鸭子，那它就是鸭子

4. 高内聚低耦合，是判断软件设计好坏的标准。在程序设计中，我们都希望尽可能做到高内聚（内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事，它描述的是模块内的功能联系）和低耦合（耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据）。那么请问，使用鸭子类型，是增强了内聚呢，还是降低了耦合度呢？
高内聚

5. 请问下面代码的执行结果，是属于 Python 的多态现象吗？
不是

动动手：
#员工属性
class Users:
    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

#计算工资
class Money:
    def salary(self,job,grade,year):
        if job=="E":
            money=3000+500*grade+50*year
        elif job=="T":
            money=4000+800*grade+100*year
        elif job=="M":
            money=5000+1000*(grade+year)
        return money



class Action(Money):
    def __init__(self):
        self.users={}
        self.no=10000

    #启动程序   
    def begin(self):
        a=0
        while a !="5":
            a=input("\n1.录入；2.查询；3.升级；4.降级；5.退出：")
            if a=="1":
                self.insert()
            elif a=="2":
                self.search()
            elif a=="3":
                self.up()
            elif a=="4":
                self.down()
            elif a=="5":
                break
            
    #录入
    def insert(self):
        name=input("姓名：")
        job=input("职位（E.普通员工；T.组长；M.经理）：")
        year=int(input("工龄："))
        grade=int(input("级别："))
        if job=="E":
            if grade >10 or grade <1:
                grade=int(input("该职位最高级别为10，请重新录入级别："))
        elif job=="T":
            if grade >6 or grade <1:
                grade=int(input("该职位最高级别为6，请重新录入级别："))
        elif job=="M":
            if grade >3 or grade <1:
                grade=int(input("该职位最高级别为3，请重新录入级别："))     
        uid=self.no
        self.users[self.no]=Users(name,job,grade,year,uid)
        money=self.salary(job,grade,year)
        print(f"录入成功！姓名：{name}，工号：{uid}，薪资：{money}")
        self.no+=1

    #查询
    def search(self):
        whichsearch=input("1.员工查询；2.职位查询：")
        if whichsearch =="1":
            uid=int(input("请输入工号："))
            if not self.users.get(uid):
                print("该工号不存在！")
            else:
                print(f"姓名：{self.users[uid].name}")
                print(f"职位：{self.users[uid].job}")
                print(f"级别：{self.users[uid].grade}")
                print(f"工龄：{self.users[uid].year}")
                print(f"薪资：{self.salary(self.users[uid].job,self.users[uid].grade,self.users[uid].year)}")
        if whichsearch =="2":
            job=input("职位（E.普通员工；T.组长；M.经理）：")
            total=0
            for i in self.users:
                if self.users[i].job==job:
                    total+=1
            if total==0:
                if job=="E":
                    print(f"目前公司没有普通员工！")
                elif job=="T":
                    print(f"目前公司没有组长！")
                elif job=="M":
                    print(f"目前公司没有经理！")   
            else:
                print(f"目前普通员工共有{total}人：")
                for i in self.users:
                    if self.users[i].job==job:
                        print(f"{self.users[i].uid} - {self.users[i].name}")

    #升级
    def up(self):
        uid=int(input("请输入工号："))
        print(f"{self.users[uid].name}，工号：{uid}，当前职位：{self.users[uid].job}{self.users[uid].grade}，当前薪资：{self.salary(self.users[uid].job,self.users[uid].grade,self.users[uid].year)}")
        new=int(input("请输入需要增加的级别："))
        if self.users[uid].job=="E":
            if self.users[uid].grade+new <=10:
                newgrade=self.users[uid].grade+new
            if self.users[uid].grade+new >10 and self.users[uid].grade <17:
                newgrade=1
                newjob="T"
            if self.users[uid].grade+new >=17:
                newgrade=1
                newjob="M"
        elif self.users[uid].job=="T":
            if self.users[uid].grade+new <=6:
                newgrade=self.users[uid].grade+new
            if self.users[uid].grade+new >6:
                newgrade=1
                newjob="M"     
        elif self.users[uid].job=="M":
            newgrade=self.users[uid].grade+new
        print("升级成功！")
        print(f"{self.users[uid].name}，工号：{uid},升级后职位：{newjob}{newgrade},升级后的薪资：{self.salary(newjob,newgrade,self.users[uid].year)}(+{self.salary(newjob,newgrade,self.users[uid].year)-self.salary(self.users[uid].job,self.users[uid].grade,self.users[uid].year)})")
        self.users[uid].job=newjob
        self.users[uid].grade=newgrade
   

    #降级
    def down(self):
        uid=int(input("请输入工号："))
        print(f"{self.users[uid].name}，工号：{uid}，当前职位：{self.users[uid].job}{self.users[uid].grade}，当前薪资：{self.salary(self.users[uid].job,self.users[uid].grade,self.users[uid].year)}")
        new=int(input("请输入需要减少的级数："))
        if self.users[uid].job=="E":
            if self.users[uid].grade-new <=0:
                newgrade=self.users[uid].grade-new
        elif self.users[uid].job=="T":
            if self.users[uid].grade+10-new >10:
                newgrade=self.users[uid].grade-new
            if self.users[uid].grade+new <=10:
                newgrade=10
                newjob="E"     
        elif self.users[uid].job=="M":
            if self.users[uid].grade+16-new>16:
                newgrade=self.users[uid].grade-new
            if self.users[uid].grade+16-new>10 and self.users[uid].grade+16-new<=16:
                newgrade=6
                newjob="T"
            if  self.users[uid].grade+16-new<=10:
                newgrade=10
                newjob="E"
        print("降级成功！")
        print(f"{self.users[uid].name}，工号：{uid},降级后职位：{newjob}{newgrade},降级后的薪资：{self.salary(newjob,newgrade,self.users[uid].year)}({self.salary(newjob,newgrade,self.users[uid].year)-self.salary(self.users[uid].job,self.users[uid].grade,self.users[uid].year)})")
        self.users[uid].job=newjob
        self.users[uid].grade=newgrade
            

def main():
    m=Action()
    m.begin()

百苦

0.子类可以重写父类的同名方法
1.子类可以重写父类的同名方法
2.可以
3.一只鸟长得像鸭子,叫声像鸭子,走路也像鸭子,那它就是鸭子
5.不是

さ上官蕭痕く

问答题：
0.子类都继承了同一个父类，且都重写了父类的构造函数和方法
1.在不检查类的情况下，可以直接执行不同的子类，从而得到不同的效果
2.可以
3.黑猫白猫，能抓老鼠的就是好猫
4.高内聚，低耦合
5.不是，此代码没有继承，且只是单纯的默认参数赋值而已
动动手
0.

电蟒蛇

1

扣卡

，

扣卡

，

mengtaiqi

1

丢的FC

朕想知道

pompon

1

15232160580

啊

jianghongz

学习

FanXing3

我曾经跨过山和大海,也传过人山人海

yixuechengchi

yes

黯然销魂辣

answer

suyas9445

問答題：
0. 不同物件可以定義相同名字的方法
1. 減少需要定義的物件數量
2. 可以
3. 一支鳥走起來像鴨子，叫起來像鴨子，牠就是一隻鴨子
4. 低耦合
5. 不是

動手：
class Employee:
    def __init__(self,
                 name,
                 job,
                 grade,
                 year,
                 uid
                 ) -> None:
        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 * self.grade + 50 * self.year
        if self.job == "T":
            return 4000 + 800 * self.grade + 100 * self.year
        if self.job == "M":
            return 5000 + 1000 * (self.grade + self.year)
        
class Interface:
    job_grade = {
        "E":10,
        "T":6,
        "M":3
    }

    job_up = {
        "E":"T",
        "T":"M"
    }

    job_down = {
        "T":"E",
        "M":"T"
    }

    def __init__(self) -> None:
        self.employees = {}
        self.uid = 10000

    def regist(self):
        name = str(input("姓名："))
        job = str(input("職位(E：普通員工；T：組長；M：經理)："))
        year = int(input("工齡："))
        grade = int(input("級別："))
        while grade > Interface.job_grade[job]:
            grade = int(input(f"該職位最高級別為{Interface.job_grade[job]}，請重新輸入級別："))
        self.employees[self.uid] = Employee(name, job, grade, year, self.uid)
        print(f"登入成功！ 姓名：{self.employees[self.uid].name}，工號：{self.employees[self.uid].uid}，薪資：{self.employees[self.uid].salary()}")
        self.uid += 1

    def query_employee(self):
        uid = int(input("請輸入工號："))
        if not uid in self.employees:
            print("該工號不存在！")
            return
        
        print(f"姓名：{self.employees[uid].name}")
        print(f"職位：{self.employees[uid].job}")
        print(f"級別：{self.employees[uid].grade}")
        print(f"工齡：{self.employees[uid].year}")
        print(f"薪資：{self.employees[uid].salary()}")

    def query_job(self):
        job_name = {
            "E":"普通員工",
            "T":"組長",
            "M":"經理"
        }
        job = str(input("職位(E：普通員工；T：組長；M：經理)："))
        result = [ info for uid, info in self.employees.items() if info.job == job ]
        print(f"目前{job_name[job]}共有{len(result)}人：")
        for each in result:
            print(f"{each.uid} - {each.name}")

    def query_interface(self):
        function_dict = {
            1:self.query_employee,
            2:self.query_job
        }
        query = int(input("1.員工查詢；2.職位查詢："))

        function_dict[query]()

    def upgrade(self):
        uid = int(input("請輸入工號："))
        if not uid in self.employees:
            print("該工號不存在！")
            return
        employee = self.employees[uid]
        presalary = employee.salary()
        print(f"{employee.name}，工號：{employee.uid}，當前職位：{employee.job}{employee.grade}，當前薪資：{employee.salary()}")
        up = int(input("請輸入需要增加的級數："))
        if employee.grade + up > Interface.job_grade[employee.job]:
            employee.job = Interface.job_up[employee.job]
            employee.grade = 1
        else:
            employee.grade += up
        
        print("升級成功！")
        print(f"{employee.name}，工號：{employee.uid}，升級後職位：{employee.job}{employee.grade}，升級後薪資：{employee.salary()}({'+' if employee.salary() - presalary > 0 else ''}{employee.salary() - presalary})")
        
    def downgrade(self):
        uid = int(input("請輸入工號："))
        if not uid in self.employees:
            print("該工號不存在！")
            return
        employee = self.employees[uid]
        presalary = employee.salary()
        print(f"{employee.name}，工號：{employee.uid}，當前職位：{employee.job}{employee.grade}，當前薪資：{employee.salary()}")
        down = int(input("請輸入需要減少的級數："))
        if employee.grade - down < 1:
            employee.job = Interface.job_down[employee.job]
            employee.grade = Interface.job_grade[employee.job]
        else:
            employee.grade -= down
        
        print("降級成功！")
        print(f"{employee.name}，工號：{employee.uid}，降級後職位：{employee.job}{employee.grade}，降級後薪資：{employee.salary()}({'+' if employee.salary() - presalary > 0 else ''}{employee.salary() - presalary})")

    def start(self):
        function_dict = {
            1:self.regist,
            2:self.query_interface,
            3:self.upgrade,
            4:self.downgrade,
        }
        while True:
            query = int(input("1.登錄；2.查詢；3.升級；4.降級；5.退出："))
            if query == 5:
                break

            function_dict[query]()

interface = Interface()
interface.start()

火樂神

0.python中的+和*遇到不同的类型会执行不同的运算
1.通过改变不同的场景，用同一种方法、函数、对象来实现不同的效果，可以显著减少代码的复杂程度
2.可以
3.“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
4.降低了耦合？
5.不是

0.
class Staff:
    def __init__(self,name,grade,year,uid):
        self.name = name
        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
class Employee(Staff):
    member = []
    def __init__(self,name,grade,year,uid):
        self.job = "Employee"
        grade = "E" + str(grade)
        super().__init__(name,grade,year,uid)
        Employee.member += [self.uid]
    def salary(self):
        return 3000 + 500 * int(self.grade[1:]) + 50 * self.year
class Teamleader(Staff):
    member = []
    def __init__(self,name,grade,year,uid):
        self.job = "Teamleader"
        grade = "T" + str(grade)
        super().__init__(name,grade,year,uid)
        Teamleader.member += [self.uid]
    def salary(self):
        return 4000 + 800 * int(self.grade[1:]) + 100 * self.year
class Manager(Staff):
    member = []
    def __init__(self,name,grade,year,uid):
        self.job = "Manager"
        grade = "M" + str(grade)
        super().__init__(name,grade,year,uid)
        Manager.member += [self.uid]
    def salary(self):
        return 5000 + 1000 * (int(self.grade[1:]) + self.year)

class Manage:
    def __init__(self):
        self.staff = dict()
        self.uid = 10000
    def program(self):
        ins = 0
        while ins != '5':
            ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
            if ins == '1':
                self.enter()
            elif ins == '2':
                self.search()
            elif ins == '3':
                self.upgrade()
            elif ins == '4':
                self.downgrade()
            elif ins != "5":
                print("请输入正确的指令")

    def confirm_uid(self):
        uid = int(input("请输入工号："))
        if not self.staff.get(uid):
            print("该工号不存在！")
            return 0
        else:
            return uid
    def confirm_job(self):
        job = input("职位（E.普通员工；T.组长；M.经理）：")
        while job not in('E','T','M'):
            print("请输入正确的指令")
            job = input("职位（E.普通员工；T.组长；M.经理）：")
        return job
   
    def enter(self):
        name = input("姓名：")
        job = self.confirm_job()
        year = int(input("工龄："))
        if job == "E":
            grade = int(input("级别："))
            while grade > 10:
                grade = int(input("该职位最高级别为10，请重新录入级别："))
            self.staff[self.uid] = Employee(name,grade,year,self.uid)
        elif job == "T":
            grade = int(input("级别："))
            while grade > 6:
                grade = int(input("该职位最高级别为6，请重新录入级别："))
            self.staff[self.uid] = Teamleader(name,grade,year,self.uid)
        else:
            grade = int(input("级别："))
            while grade > 3:
                grade = int(input("该职位最高级别为3，请重新录入级别："))
            self.staff[self.uid] = Manager(name,grade,year,self.uid)
        print(f"录入成功！姓名：{name}，工号：{self.uid},薪资：{self.staff[self.uid].salary()}")
        self.uid += 1

    def search(self):
        ins = input("1.员工查询；2.职位查询：")
        if ins == '1':
            uid = self.confirm_uid()
            if uid:
                print(f"姓名：{self.staff[uid].name}\n职位：{self.staff[uid].job}\n级别：{self.staff[uid].grade}\n工龄：{self.staff[uid].year}\n薪资：{self.staff[uid].salary()}")
        elif ins == '2':
            job = self.confirm_job()
            if job == "E":
                job = "普通员工"
                member = Employee.member
            elif job == "T":
                job = "组长"
                member = Teamleader.member
            else:
                job = "经理"
                member = Manager.member
            if len(member) != 0:
                print(f"目前{job}共有{len(member)}人")
                for each in member:
                    print(f"{each} - {self.staff[each].name}")
            else:
                print(f"目前公司没有{job}！")

    def upgrade(self):
        uid = self.confirm_uid()
        if uid:
            grade = self.staff[uid].grade
            salary = self.staff[uid].salary()
            print(f"{self.staff[uid].name}，工号：{uid}，当前职位：{grade}，当前薪资：{self.staff[uid].salary()}")
            num = int(input("请输入需要增加的级数："))
            if grade[0] == "E":
                if int(grade[1:]) + num <= 10:
                    self.staff[uid].grade = "E" + str(int(grade[1:])+num)
                else:
                    grade = 1
                    self.staff[uid] = Teamleader(self.staff[uid].name,grade,self.staff[uid].year,uid)
                    Employee.member.remove(uid)
            elif grade[0] == 'T':
                if int(grade[1:]) + num <= 6:
                    self.staff[uid].grade = "T" + str(int(grade[1:])+num)
                else:
                    grade = 1
                    self.staff[uid] = Manager(self.staff[uid].name,grade,self.staff[uid].year,uid)
                    Teamleader.member.remove(uid)
            else:
                if int(grade[1:]) + num <= 3:
                    self.staff[uid].grade = "M" + str(int(grade[1:])+num)
                else:
                    print("请输入正确的级数！")
                    return
            print("升级成功！")
            print(f"{self.staff[uid].name}，工号：{uid}，升级后职位：{self.staff[uid].grade}，升级后薪资：{self.staff[uid].salary()}（+{self.staff[uid].salary()-salary}）")

    def downgrade(self):
        uid = self.confirm_uid()
        if uid:
            grade = self.staff[uid].grade
            salary = self.staff[uid].salary()
            print(f"{self.staff[uid].name}，工号：{uid}，当前职位：{grade}，当前薪资：{self.staff[uid].salary()}")
            num = int(input("请输入需要增加的级数："))
            if grade[0] == "E":
                if int(grade[1:]) - num > 0:
                    self.staff[uid].grade = "E" + str(int(grade[1:])-num)
                else:
                    print("请输入正确的级数！")
                    return
            elif grade[0] == 'T':
                if int(grade[1:]) - num > 0:
                    self.staff[uid].grade = "T" + str(int(grade[1:])-num)
                else:
                    grade = 6
                    self.staff[uid] = Employee(self.staff[uid].name,grade,self.staff[uid].year,uid)
                    Teamleader.member.remove(uid)
            else:
                if int(grade[1:]) - num > 0:
                    self.staff[uid].grade = "E" + str(int(grade[1:])-num)
                else:
                    grade = 6
                    self.staff[uid] = Teamleader(self.staff[uid].name,grade,self.staff[uid].year,uid)
                    Manager.member.remove(uid)
            print("降级成功！")
            print(f"{self.staff[uid].name}，工号：{uid}，降级后职位：{self.staff[uid].grade}，降级后薪资：{self.staff[uid].salary()}(-{salary-self.staff[uid].salary()})")

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