第063讲：类和对象（VI） | 课后测试题及答案,《零基础入门学习Python》【最新版】,Python交流,鱼C论坛

wajxyy 发表于 2023-9-2 14:16:16

madaowu 发表于 2023-8-30 10:00:32

0. 继承其他类，但在不同场景下实现不同功能
1. 批量生产+自定义，提升类的创建效率
2. 可以
3. 如果像鸭子一样走路,像鸭子一样呱呱叫,那它就是一只鸭子
4. 降低耦合度
5. 不是

阳光shine 发表于 2023-8-28 10:51:34

bairuijie123 发表于 2023-8-27 09:38:13

0.
类继承的多态：即可以通过继承的方法，在子类中更改父类的方法从而实现多态，也可以自定义函数的多态。

1.
可以使用同一个函数从而实现不同的效果

2.
可以，一个是算数运算，一个是字符串拼接

3.
如果我看到一只鸟，它长得像鸭子，走路游泳也像鸭子，那么我认为他就是鸭子

4.
增强了内聚

5.
不属于

alenshaw 发表于 2023-8-26 19:11:40

btbt

no

no

di

no

onelike 发表于 2023-8-25 19:52:33

class Personnel:
def __init__(self,name,job,grade,year,uid):
   self.name = name
   self.job = job
   self.grade = int(grade)
   self.year = int(year)
   self.uid = uid
   self.wage = 0

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 salary(self):
   if self.job == 'E':
         self.wage = 3000 + 500 * self.grade + 50 * self.year
   elif self.job == 'T':
         self.wage = 4000 + 800 * self.grade + 100 * self.year
   elif self.job == 'M':
         self.wage = 5000 + 1000 * (self.grade + self.year)
   return self.wage

def adj_grade(self):
   if self.job == 'E':
         if self.grade > 10:
            self.job = 'T'
            self.grade = 1
         elif self.grade < 1:
            sele.grade = 1
   elif self.job == 'T':
         if self.grade < 1:
            self.job = 'E'
            self.grade = 10
         elif self.grade > 6:
            self.job = 'M'
            self.grade = 1
   elif self.job == 'M':
         if self.grade < 1:
            self.job = 'T'
            self.grade = 6
         elif self.grade > 3:
            self.grade = 3

class Manage:
def __init__(self):
   self.personnel = {}
   self.E = []
   self.T = []
   self.M = []
   self.uid = 10000

def use(self):
   ins = input('1.录入;2.查询;3.升级;4.降级;5.退出:')
   while ins != '5':
         if ins == '1':
            self.add_people()
         if ins == '2':
            self.check()
         if ins == '3':
            self.upgrade()
         if ins == '4':
            self.demote()
         ins = input('\n1.录入;2.查询;3.升级;4.降级;5.退出:')

def add_people(self):
   name = input('姓名:')
   job = input('职位(E.普通员工;T.组长;M.经理):')
   year = input('工龄:')
   grade = input('级别:')
   p = Personnel(name,job,grade,year,self.uid)
   self.personnel = p
   if job == 'E':
         self.E.append((str(self.uid),name))
   if job == 'T':
         self.T.append((str(self.uid),name))
   if job == 'M':
         self.M.append((str(self.uid),name))
   print(f'录入成功!姓名:{name},工号:{self.uid},薪资:{p.salary()}')
   self.uid += 1

def check(self):
   op = input('1.员工查询;2.职位查询:')
   if op == '1':
         uid = int(input('请输入工号:'))
         if uid not in self.personnel:
            print('该工号不存在!')
         else:
            p = self.personnel
            print('姓名:',p.name)
            print('职位:',p.job)
            print('级别:',p.grade)
            print('工龄:',p.year)
            print('薪资:',p.wage)
   if op == '2':
         grade = input('职位(E.普通员工;T.组长;M.经理):')
         if grade == 'E':
            if self.E:
               print(f'目前普通员工共有{len(self.E)}人')
               for each in self.E:
                     print(' - '.join(each))
            else:
               print('目前公司没有普通员工!')
         if grade == 'T':
            if self.T:
               print(f'目前组长共有{len(self.T)}人')
               for each in self.T:
                     print(' - '.join(each))
            else:
               print('目前公司没有组长!')
         if grade == 'M':
            if self.M:
               print(f'目前普通员工共有{len(self.M)}人')
               for each in self.M:
                     print(' - '.join(each))
            else:
               print('目前公司没有普通员工!')

def upgrade(self):
   uid = int(input('请输入工号:'))
   if self.personnel.get(uid):
         person = self.personnel
         old_wage = person.wage
         print(f'{person.name},工号:{uid},当前职位:{person.job}{person.grade},当前薪资:{person.wage}')
         num = int(input('请输入需要增加的级数:'))
         person.grade += num
         person.adj_grade()
         person.salary()
         print('升级成功!')
         new_wage = person.wage
         adjust = new_wage - old_wage
         print(f'{person.name},工号:{uid},升级后职位:{person.job}{person.grade},升级后薪资:{new_wage}({adjust:+})')
   else:
         print('该工号不存在')

def demote(self):
   uid = int(input('请输入工号:'))
   if self.personnel.get(uid):
         person = self.personnel
         old_wage = person.wage
         print(f'{person.name},工号:{uid},当前职位:{person.job}{person.grade},当前薪资:{person.wage}')
         num = int(input('请输入需要减少的级数:'))
         person.grade -= num
         person.adj_grade()
         person.salary()
         print('降级成功!')
         new_wage = person.wage
         adjust = new_wage - old_wage
         print(f'{person.name},工号:{uid},降级后职位:{person.job}{person.grade},降级后薪资:{new_wage}({adjust:+})')
   else:
         print('该工号不存在')

def main():
m = Manage()
m.use()

喜喜1 发表于 2023-8-25 14:51:14

查看

encyclopedia 发表于 2023-8-25 07:39:49

青对发表于 2023-8-24 19:12:01

0.针对不同对象有不同的操作。
2.可以
4.增强了内聚。

krabs12138 发表于 2023-8-23 17:06:01

张三ccccccc 发表于 2023-8-21 16:01:11

本帖最后由张三ccccccc 于 2023-8-22 12:42 编辑

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:
##员工属性
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 set_grade(self,grade):
   self.grade = grade
##获取工龄
def get_year(self):
   return self.year
##统计并返回工资
def salary(self):
   return 3000+500*self.grade+50*self.year

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

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

def main():
result = {}
jobs ={'E':[],'T':[],'M':[]}
uid = 10000
max_E_Grade = 10
max_T_Grade = 6
max_M_Grade = 3
##录入功能
def log_in():
   name = input("姓名：")
   job =input("职位(E:普通员工；T:组长；M:经理)：")
   year = int(input("工龄："))
   grade = int(input("级别："))
   nonlocal uid
   if job == 'E':
         while grade > max_E_Grade:
            grade = int(input(f"该职位的最高级别为{max_E_Grade},请重新录入级别(1~10)："))
         e = Employee(name,job,grade,year,uid)
         result = e
         jobs['E'].append(e)
   if job == 'T':
         while grade > max_T_Grade:
            grade = int(input(f"该职位的最高级别为{max_T_Grade},请重新录入级别(1~6)："))
         e = Teamleader(name,job,grade,year,uid)
         result = e
         jobs['T'].append(e)
   if job == 'M':
         while grade > max_M_Grade:
            grade = int(input(f"该职位的最高级别为{max_M_Grade},请重新录入级别(1~3)："))
         e = Manager(name,job,grade,year,uid)
         result = e
         jobs['M'].append(e)
   print(f"录入成功！姓名：{name},工号：{uid},工龄{year}")
   uid += 1
##查询功能
def Search():

   ##员工查询
   def Employee_search():
         uid1 = int(input("请输入工号："))
         if result.get(uid1):
            e = result##实例化Employee Teamleader Manager 这三个对象中的一个
            print(f"姓名：{e.get_name()}\n 职位：{e.get_job()}\n 级别：{e.get_grade()}\n工龄:{e.get_year()} ")
            ##获取薪资
            print(f"薪资：{e.salary()}")
         else:
            print("该工号不存在！")
   ##职位查询
   def Grade_search():
         job = input("职位(E:普通员工；T：组长；M：经理)：")
         if job =='E':
            if jobs['E']:
               print(f"目前普通员工共有{len(jobs['E'])}人")
               for each in jobs['E']:
                     print(f"{each.get_uid()}-{each.get_name()}")
            else:
               print(f"目前公司没有普通员工!")
         if job =='T':
            if jobs['T']:
               print(f"目前普通员工共有{len(jobs['T'])}人")
               for each in jobs['T']:
                     print(f"{each.get_uid()}-{each.get_name()}")
            else:
               print(f"目前公司没有组长!")
         if job =='M':
            if jobs['M']:
               print(f"目前普通员工共有{len(jobs['M'])}人")
               for each in jobs['M']:
                     print(f"{each.get_uid()}-{each.get_name()}")
            else:
               print(f"目前公司没有经理!")

   search_number = input("1.员工查询；2.职位查询：")
   if search_number =="1":
         Employee_search()
   if search_number == "2":
         Grade_search()

##升级功能
def UpGrade():
   uid1 = int(input("请输入工号："))
   if result.get(uid1):
         e = result
         print(f"姓名：{e.get_name()},工号:{e.get_uid()},当前职位:{e.get_job()}{e.get_grade()}，当前薪资:{e.salary()}")
         name = e.get_name()
         job = e.get_job()
         year = e.get_year()
         grade = e.get_grade()
         old_salary = e.salary()
         uid = e.get_uid()

         upgrade_num =int(input("请输入需要增加的级数："))
         if job == 'E':
            if grade + upgrade_num > max_E_Grade:
               job = 'T'
               grade = 1
               jobs['E'].remove(e)
               e = Teamleader(name,job,grade,year,uid)
               jobs['T'].append(e)
               result = e
            else:
               e.set_grade(grade + upgrade_num)
         elif job == 'T':
            if grade + upgrade_num > max_T_Grade:
               job = 'M'
               grade = 1
               jobs['T'].remove(e)
               e = Manager(name,job,grade,year,uid)
               jobs['M'].append(e)
               result = e
            else:
               e.set_grade(grade + upgrade_num)
         elif job == 'M':
            if grade + upgrade_num > max_M_Grade:
               print("已达到最高级别！")
               grade = max_M_Grade
            else:
               e.set_grade(garde + upgrade_num)
         new_salary = e.salary()
         print("升级成功！")
         print(f"姓名：{e.get_name()},工号:{e.get_uid()},当前职位:{e.get_job()}{e.get_grade()},当前薪资：{e.salary()},+({new_salary-old_salary})")
   else:
         print("该工号不存在")
##降级
def DownGrade():
   uid1 = int(input("请输入工号："))
   if result.get(uid1):
         e = result
         print(f"姓名:{e.get_name()},工号:{e.get_uid()},当前职位:{e.get_job()}{e.get_grade()},当前薪资:{e.salary()}")
         name = e.get_name()
         job = e.get_job()
         year = e.get_year()
         grade = e.get_grade()
         old_salary = e.salary()
         uid = e.get_uid()
         upgrade_num =int(input("请输入需要减少的级数："))
         if job == 'E':
            if grade - upgrade_num <= 0:
               print("已经是最低职位")
               grade =1
            else:
               e.set_grade(grade-upgrade_num)
         elif job == 'T':
            if grade - upgrade_num <= 0:
               job = 'E'
               grade = max_E_Grade
               jobs['T'].remove(e)
               e = Employee(name,job,grade,year,uid)
               jobs['E'].append(e)
               result = e
            else:
               e.set_grade(grade - upgrade_num)
         elif job == 'M':
            if grade-upgrade_num <1:
               job = 'T'
               grade = max_T_Grade
               jobs['M'].remove(e)
               e = Teamleader(name,job,grade,year,uid)
               jobs['T'].append(e)
               result = e
            else:
               e.set_grade(garde - upgrade_num)
         new_salary = e.salary()
         print("降级成功！")
         print(f"姓名:{e.get_name()},工号:{e.get_uid()},当前职位:{e.get_job()}{e.get_grade()}，当前薪资:{e.salary()},({new_salary-old_salary)}")
   else:
         print("该工号不存在")

##主程序
number = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
while number != "5":
   if number == "1":
         log_in()
   if number == "2":
         Search()
   if number == "3":
         UpGrade()
   if number == "4":
         DownGrade()
   number = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
else:
   print("欢迎使用本管理程序~")

醉酒不如梦 发表于 2023-8-20 15:29:09

对象间的继承关系可有可无
灵活性好
可以
高内聚
不是

Alchemy_W 发表于 2023-8-18 17:15:55

0.
即使不知道一个变量是何种类型，但只要符合规则，仍能够使用变量调用方法
1.
使得代码可以快速替换使用，只需要更改变量及相关信息即可
2.
我觉得可以，他们本质上仍然是相加后进行布尔运算
3.
当我看到一只像鸭子一样走路、像鸭子一样游泳、像鸭子一样叫的鸟时，我称那只鸟为鸭子。
4.
降低耦合
5.
不属于，这种是同一类型（？不太确定）

0.

2353171408 发表于 2023-8-16 15:50:22

多态在编程中是一个非常重要的概念，它是指同一个运算符、函数或对象在不同的场景下，具有不同的作用效果，这么一个技能。

“见机行事”

可以’

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.

低耦合

是

2986745766 发表于 2023-8-16 12:48:52

nidepaidaxing 发表于 2023-8-14 09:31:46

11111

ROCK陶先生 发表于 2023-8-13 15:20:47

0、不知道
1、方便
2、可以
3、不知道
4、低偶合
5、不属于
6、

叶落知秋iu 发表于 2023-8-13 10:48:17

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

JunStill 发表于 2023-8-12 16:33:05

iyuc 发表于 2023-8-12 15:46:08

‘’

页: 22 23 24 25 26 27 28 29 30 31 [32] 33 34 35 36 37 38 39 40 41

鱼C论坛's Archiver