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

tuuuuuuco

《零基础入门学习Python》

（最新版）

小甲鱼 著

立即购买

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

zbzwda

请回复您的答案^_^

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

第 0 题的答案是：
一个固定的函数可以实现不同的功能
第 1 题的答案是：
灵活
第 2 题的答案是：
可以
第 3 题的答案是：

第 4 题的答案是：
高内聚
第 5 题的答案是：
是的
-------- 动动手 --------

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

zhengss

请回复您的答案^_^

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

第 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 题的代码写在下方：
class Employee:
    employee_beginsno = 10000
    employee_lastsno = 0

    def __init__(self, name, job, year, grade, uid=0):
        self.name = name
        self.job = job
        self.grade = grade
        self.year = year

        if uid != 0:
            self.uid = uid
        else:
            if Employee.employee_lastsno == 0:
                self.uid = Employee.employee_beginsno
            else:
                self.uid = Employee.employee_lastsno + 1

            Employee.employee_lastsno = self.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):
        return 3000 + self.grade * 500 + self.year * 50


class Teamleader(Employee):
    def __init__(self, name, job, year, grade, uid=0):
        super().__init__(name, job, year, grade, uid)

    def salary(self):
        return 4000 + self.grade * 800 + self.year * 100


class Manager(Employee):
    def __init__(self, name, job, year, grade, uid=0):
        super().__init__(name, job, year, grade, uid)

    def salary(self):
        return 5000 + self.grade * 1000 + self.year * 1000


class EmployeeManage:
    employee_list = []
    teamleader_list = []
    manager_list = []
    max_try_times = 3

    # 职位级别,E-普通员工：10个级别;T-组长：6个级别;M-经理：3个级别
    job_grade = {"E": 10, "T": 6, "M": 3}

    def welcome(self):
        print("欢迎使用鱼C企业员工管理系统")
        while True:
            oper_type = input("1.录入;2.查询;3.升级;4.降级;5.退出：").strip()
            if oper_type == "1":
                self.employee_lr()
            elif oper_type == "2":
                self.employee_cx()
            elif oper_type == "3":
                self.employee_sj()
            elif oper_type == "4":
                self.employee_jj()
            elif oper_type == "5":
                print("感谢使用鱼C企业员工管理系统")
                break
            else:
                print("请输入正确的操作类型")

    def employee_lr(self):
        error_times = 0
        name = input("姓名：").strip()

        job = ""
        while error_times < self.max_try_times:
            job = input("职位(E.普通员工;T.组长;M.经理)：").strip()
            if job not in ["E", "T", "M"]:
                error_times += 1
                print("请输入正确的职位类型")
            else:
                break
        else:
            print("输入错误次数过多，请重新输入")
            return

        error_times = 0
        year = 0
        while error_times < self.max_try_times:
            v_year = input("工龄：").strip()
            if v_year.isdigit() == False or int(v_year) < 0 or int(v_year) > 100:
                error_times += 1
                print("请输入正确的工龄")
            else:
                year = int(v_year)
                break
        else:
            print("输入错误次数过多，请重新输入")
            return

        error_times = 0
        grade = 0
        while error_times < self.max_try_times:
            v_grade = input("级别：").strip()
            if (
                v_grade.isdigit() == False
                or int(v_grade) < 0
                or int(v_grade) > self.job_grade[job]
            ):
                error_times += 1
                print(f"该职位最高级别为{self.job_grade[job]}，请重新输入")
            else:
                grade = int(v_grade)
                break
        else:
            print("输入错误次数过多，请重新输入")
            return

        employee = None
        if job == "E":
            employee = Employee(name, job, year, grade)
            self.employee_list.append(employee)
        elif job == "T":
            employee = Teamleader(name, job, year, grade)
            self.teamleader_list.append(employee)
        elif job == "M":
            employee = Manager(name, job, year, grade)
            self.manager_list.append(employee)

        if employee:
            print(
                f"录入成功！姓名：{name}，工号：{employee.get_uid()}，薪资：{employee.salary()}"
            )

    def employee_cx(self):
        error_times = 0
        while error_times < self.max_try_times:
            cx_type = input("1.员工查询;2.职位查询：").strip()
            if cx_type == "1":
                id = input("员工编号：").strip()
                employee = self.exist_employee(id)
                if employee:
                    self.print_employee(employee)
                    break
                else:
                    print("该工号不存在！")
            elif cx_type == "2":
                job = input("职位(E.普通员工;T.组长;M.经理)：").strip()
                self.job_employee(job)
                break
            else:
                error_times += 1
                print("请输入正确的查询类型")

    def employee_sj(self):
        id = input("请输入工号：").strip()
        employee = self.exist_employee(id)
        if not employee:
            print("该工号不存在！")
            return

        print(
            f"姓名：{employee.get_name()},工号：{employee.get_uid()}，职位：{employee.get_job()}{employee.get_grade()}，当前薪资：{employee.salary()}"
        )

        job = employee.get_job()
        grade = employee.get_grade()

        add_grade = input("请输入要增加的级数：").strip()
        if (
            add_grade.isdigit() == False
            or int(add_grade) < 0
            or int(add_grade) + employee.get_grade() > 19
        ):
            print("请输入正确的级别")
            return

        # 主要超过当前职位级别，则升级为下一个职位，并且级别设置为当前职位级别1
        new_employee = None
        old_salary = employee.salary()
        sj_flag = True
        if job == "E":
            if grade + int(add_grade) > self.job_grade["E"]:
                new_job = "T"
                new_grade = 1
                new_employee = Teamleader(
                    employee.get_name(),
                    new_job,
                    employee.get_year(),
                    new_grade,
                    employee.get_uid(),
                )
                self.teamleader_list.append(new_employee)
                self.employee_list.remove(employee)
            else:
                employee.grade += int(add_grade)
        elif job == "T":
            if grade + int(add_grade) > self.job_grade["T"]:
                new_job = "M"
                new_grade = 1
                new_employee = Manager(
                    employee.get_name(),
                    new_job,
                    employee.get_year(),
                    new_grade,
                    employee.get_uid(),
                )
                self.manager_list.append(new_employee)
                self.teamleader_list.remove(employee)
            else:
                employee.grade += int(add_grade)
        elif job == "M":
            if grade + int(add_grade) > self.job_grade["M"]:
                sj_flag = False
                print("无法升级")
            else:
                employee.grade += int(add_grade)

        if sj_flag:
            print("升级成功！")
            add_salary = new_employee.salary() - old_salary
            print(
                f"姓名：{new_employee.get_name()}，工号：{new_employee.get_uid()}，职位：{new_employee.get_job()}{new_employee.get_grade()}，当前薪资：{new_employee.salary()}(+{add_salary})"
            )

    def employee_jj(self):
        id = input("请输入工号：").strip()
        employee = self.exist_employee(id)
        if not employee:
            print("该工号不存在！")
            return

        print(
            f"姓名：{employee.get_name()},工号：{employee.get_uid()}，职位：{employee.get_job()}{employee.get_grade()}，当前薪资：{employee.salary()}"
        )

        job = employee.get_job()
        grade = employee.get_grade()

        add_grade = input("请输入要减少的级数：").strip()
        if add_grade.isdigit() == False or int(add_grade) < 0:
            print("请输入正确的级别")
            return

        # 主要小于当前职位的最低级别，则降级为下一个职位的最高级别
        new_employee = None
        old_salary = employee.salary()
        jj_flag = True
        if job == "E":
            if grade - int(add_grade) <= 0:
                employee.grade = 1
            else:
                employee.grade = grade - int(add_grade)
        elif job == "T":
            if grade - int(add_grade) <= 0:
                new_job = "E"
                new_grade = 10
                new_employee = Employee(
                    employee.get_name(),
                    new_job,
                    employee.get_year(),
                    new_grade,
                    employee.get_uid(),
                )
                self.employee_list.append(new_employee)
                self.teamleader_list.remove(employee)
            else:
                employee.grade -= int(add_grade)
        elif job == "M":
            if grade - int(add_grade) <= 0:
                new_job = "T"
                new_grade = 6
                new_employee = Teamleader(
                    employee.get_name(),
                    new_job,
                    employee.get_year(),
                    new_grade,
                    employee.get_uid(),
                )
                self.teamleader_list.append(new_employee)
                self.manager_list.remove(employee)
            else:
                employee.grade -= int(add_grade)

        if jj_flag:
            print("降级成功！")
            add_salary = new_employee.salary() - old_salary
            print(
                f"姓名：{new_employee.get_name()}，工号：{new_employee.get_uid()}，职位：{new_employee.get_job()}{new_employee.get_grade()}，当前薪资：{new_employee.salary()}({add_salary})"
            )

    def exist_employee(self, id):
        if id.isdigit() == False:
            return None

        for employee in self.employee_list:
            if employee.get_uid() == int(id):
                return employee

        for employee in self.teamleader_list:
            if employee.get_uid() == int(id):
                return employee

        for employee in self.manager_list:
            if employee.get_uid() == int(id):
                return employee

        return None

    def print_employee(self, employee):
        print(
            f"姓名：{employee.get_name()}",
            f"职位：{employee.get_job()}",
            f"级别：{employee.get_grade()}",
            f"工龄：{employee.get_year()}",
            f"薪资：{employee.salary()}",
            sep="\n",
        )

    def job_employee(self, job):
        if job == "E":
            if len(self.employee_list) == 0:
                print("目前公司没有普通员工")
                return
            print(f"目前普通员工有 {len(self.employee_list)} 人：")
            for employee in self.employee_list:
                print(f"{employee.get_uid()} - {employee.get_name()}")
        elif job == "T":
            if len(self.teamleader_list) == 0:
                print("目前公司没有组长")
                return
            print(f"目前组长有 {len(self.teamleader_list)} 人：")
            for employee in self.teamleader_list:
                print(f"{employee.get_uid()} - {employee.get_name()}")
        elif job == "M":
            if len(self.manager_list) == 0:
                print("目前公司没有经理")
                return
            print(f"目前经理有 {len(self.manager_list)} 人：")
            for employee in self.manager_list:
                print(f"{employee.get_uid()} - {employee.get_name()}")
        else:
            print("请输入正确的职位")


def main():
    manage = EmployeeManage()
    manage.welcome()


main()

66大顺123

请回复您的答案^_^

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

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

第 1 题的答案是：动态

第 2 题的答案是：可以

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

fishchamster

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

季汉复兴

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

苑黎伊

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

SharlkHomes

请回复您的答案^_^

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

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