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

sy133681

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

问答题：
0.
方法重写
1.
不同类型的对象只要具有同一方法，在调用该方法时不用考虑类型，直接调用，会产生不同的效果
2.
可以
3.

4.
降低了耦合。
5.
不是
动动手：
0.

yangborg_bosch

感谢小甲鱼

AKIO6666

0.通过构建不同的环境和功能， 来实现相同函数的不同功能
1.方便使用， 减少代码量
2.不可以
3.不知道~
4.内聚
5.不属于
6.

MikeDu

0

pionrrt

0.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.不是

2019721

感觉获取姓名，职业等方法不用也行啊

azkez5921

0:
我感觉就是随便定义,还不检查对象类型.只要调用的时候符合方法或属性,就不会报异常
1:
方便,方便,方便
2:
应该不能吧,这个属于类型不一致,但如果说==绝对相等的话,好像又是
3:
看山是山,看海是海
4:
感觉是增强内聚吧
5:
实现了参数传入的覆盖和默认,应该是吧

GeaAZous

1

shguk1989

越来越贵

jinyuanhan

0: 鸭子类型;方法重写; 抽象基类; 多态函数调用
1: 代码灵活性和可复用性;简化接口和提高可扩展性; 代码可读性和可维护性; 扩展性和可插拔性
2: 1+1 == 2 和 '1' + '1' == '11' 是由于操作数类型的不同而导致的结果差异。这是由于在 Python 中，加法操作符对于不同的数据类型有不同的行为定义，而不是同一种操作作用于不同类型的对象。
3: 如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子
4: 使用鸭子类型通常更加注重对象的行为和功能，而不是具体的类型。这可以有助于增强模块的内聚性和降低耦合度
5: 不是
0:

maybe2896

1

oneywa

问答题：
0:
一种东西（函数，类，运算符等）面对不同的东西（序列，函数，类等）会有不同的效果。例：
>>> 20 * 3
60
>>> "20" * 3
"202020"
1:
可以用更少的东西（函数，类，运算符等）做更多的事情，让代码变得更灵活。
2:
可以
3:
不知道
4:
降低了耦合度
5:
算
动动手：

悬崖网络

0.一是通过子类对父类方法或构造函数的重写；二是通过函数中传递类中对象，并调用类中的方法
1.可以实现不同对象有不同输出结果
2.可以
3.当你看到一只鸟走起来像鸭子，游泳起来鸭子，叫起来也像鸭子，那么这只鸟就被称为鸭子类型
4.降低了耦合度
5.不属于，表现的状态是相同的

ArielWang

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.不属于

1808694513

0.通过子类对象对父类对象的方法重写
1.增加代码通用性
2.可以
3.如果像鸭子一样走路,像鸭子一样呱呱叫,那它就是一只鸭子
4.增强了内聚
5.不属于
0.
class staff:
    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):
        pass

class Employee(staff):
   
    self.__init__(self,name,job,grade,year,uid)
   
    super().get_uid()
    super().get_name()
    super().get_job()
    super().get_grade()
    super().get_year()
   
    def salary(self):
        return 3000 + 500 * self.grade + 50 * year

class Teamleader(staff):
    self.__init__(self,name,job,grade,year,uid)
   
    super().get_uid()
    super().get_name()
    super().get_job()
    super().get_grade()
    super().get_year()
   
    def salary(self):
        return 4000 + 800 * self.grade + 100 * year

class Manager(staff):
    self.__init__(self,name,job,grade,year,uid)
   
    super().get_uid()
    super().get_name()
    super().get_job()
    super().get_grade()
    super().get_year()
   
    def salary(self):
        return 5000 + 1000 * (self.grade +  year)
   
uid = 10000

def main():
    while State != "5":
        State = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
        if State == 1:
            name = input("姓名：")
            job = input("职位（E.普通员工；T.组长；M.经理）：")
            year = input("工龄：")
            grade = input("级别：")
            while job == 'E' and grade > 10:
                grade = input("该职位最高级别为10，请重新录入级别：")
            while job == 'T' and grade > 6:
                grade = input("该职位最高级别为6，请重新录入级别：")
            while job == 'M' and grade > 3:
                grade = input("该职位最高级别为3，请重新录入级别：")
            if job == 'E':
                s = Employee(name,job,grade,year,uid)
            elif job == 'T':
                s = Teamleader(name,job,grade,year,uid)
            elif job == 'M':
                s = Manager(name,job,grade,year,uid)
            uid += 1
            print("录入成功！姓名：{}，工号：{}，薪资：{}，".format(s.get_name(),s.get_uid(),s.salary()))

fishc-闫

666

alensummer

test

xiaobit

1

阿根candice

1

bookqaqszw

0.同一个运算符，函数，对象，在不同的场景中有不同的效果
1.同一种类实现多种形式
2.可以
3.不造
4.降低耦合度
5.不是