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

jiangyadong 发表于 2026-5-28 15:48: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 题的代码写在下方：

ruoyu0305 发表于 2026-5-27 14:12:25

请回复您的答案^_^

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

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

wtchou 发表于 2026-5-24 23:31:16

{:10_249:}

mdzzxph 发表于 2026-5-20 13:34:49

请回复您的答案^_^

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

第 0 题的答案是：
不同的类可以使用相同的方法，得到不同的结果

第 1 题的答案是：
灵活

第 2 题的答案是：
是的
第 3 题的答案是：

第 4 题的答案是：
增强了
第 5 题的答案是：
不属于
-------- 动动手 --------

请将第 0 题的代码写在下方：
class user:
def __init__(self,job):
   self.job=job

def get_uid(self):
   print(f"工号: {self.uid}")

def get_name(self):
   print(f"姓名: {self.name}")

def get_job(self):
   print(f"职位: {self.job}")

def get_grade(self):
   print(f"级别: {self.grade}")

def get_year(self):
   print(f"工龄: {self.year}")

def salary(self,jc,gw,gl):
   self.mony=jc+gw*int(self.grade)+gl*int(self.year)




"""
   if self.job == 'E':
         self.mony=3000 + 500*int(self.grade)+50*int(self.year)
   elif self.job== 'T':
         self.mony=4000 + 800*int(self.grade)+100*int(self.year)
   else:
         self.mony=5000 + 1000*(int(self.grade)+int(self.year))
"""

class Employee(user):
def __init__(self,name,grade,year,uid):
   self.name=name
   self.year=year
   self.uid=uid
   super().__init__("E")
   while grade > 10:
         grade = input("该职位最高级别为10，请重新录入级别:")
   self.grade=grade

def salary(self):
   super().salary(3000,500,50)

class Teamleader(user):
def __init__(self,name,grade,year,uid):
   self.name=name
   self.year=year
   self.uid=uid
   super().__init__("T")
   while grade > 6:
         grade = int(input("该职位最高级别为10，请重新录入级别:"))
   self.grade=grade

def salary(self):
   super().salary(4000,800,100)

class Manager(user):
def __init__(self,name,grade,year,uid):
   self.name=name
   self.year=year
   self.uid=uid
   super().__init__("M")
   while grade > 3:
         grade = input("该职位最高级别为10，请重新录入级别:")
   self.grade=grade

def salary(self):
   super().salary(5000,1000,1000)

##定义功能函数
def create(count):
name=input("姓名:")
job=input("职位（E.普通员工；T.组长；M.经理）:")
year=int(input("工龄:"))
grade=int(input("级别:"))
if job == 'E':
   return Employee(name,grade,year,count)
elif job == 'T':
   return Teamleader(name,grade,year,count)
else:
   return Manager(name,grade,year,count)

def search(uid):
s=input("1.员工查询；2.职位查询:")
if s=='1':
   s2=int(input("请输入工号:"))
   if s2 not in uid:
         print("该工号不存在！")
   else:
         uid.get_name()
         uid.get_job()
         uid.get_grade()
         uid.get_year()
         uid.salary()
         print(f"当前薪资: {self.mony}")
else:
   s2=input("职位（E.普通员工;T.组长;M.经理）:")
   num = 0
   name=[]
   for i in uid:
         if uid.job == s2:
            num +=1
            name.append(.uid,uid.name])
   if s2=='E':
         print(f"目前普通员工共有{num}人:")
   elif s2=="T":
         print(f"目前组长共有{num}人:")
   else:
         print(f"目前经理共有{num}人:")
   for i in name:
         print(f"{i} - {i}")

def up(uid):
s=int(input("请输入工号:"))
if s not in uid:
   print("该工号不存在")
else:
   a=uid
   print(f"{a.name},工号:{a.uid},当前职位:{a.job}{a.grade}",end=',')
   a.salary()
   s2=int(input("请输入需增加的级数:"))
   moy=a.mony
   if uid.job == 'E':
         if (uid.grade+s2) > 10:
            uid=Teamleader(a.name,0,a.year,a.uid)
         else:
            a.grade += s2
   elif uid.job == 'T':
         if (uid.grade+s2) > 6:
            uid=Manager(a.name,0,a.year,a.uid)
         else:
            a.grade += s2
   else:
         if (uid.grade+s2) > 3:
            uid.grade = 3
         else:
            a.grade += s2
   uid.salary()
   print(f"升级成功")
   print(f"{uid.name},工号:{uid.uid},升级后职位:{uid.job}{uid.grade},升级后薪资:{uid.mony}(+{uid.mony-moy})")

def down(uid):
s=int(input("请输入工号:"))
if s not in uid:
   print("该工号不存在")
else:
   a=uid
   print(f"{a.name},工号:{a.uid},当前职位:{a.job}{a.grade}",end=',')
   a.salary()
   s2=int(input("请输入需减少的级数:"))
   moy=a.mony
   if uid.job == 'E':
         if (uid.grade-s2) < 0:
            uid.grade = 0
         else:
            a.grade -= s2
   elif uid.job == 'T':
         if (uid.grade-s2) < 0:
            uid=Employee(a.name,10,a.year,a.uid)
         else:
            a.grade -= s2
   else:
         if (uid.grade-s2) < 0:
            uid=Teamleader(a.name,6,a.year,a.uid)
         else:
            a.grade -= s2
   uid.salary()
   print(f"升级成功")
   print(f"{uid.name},工号:{uid.uid},升级后职位:{uid.job}{uid.grade},升级后薪资:{uid.mony}({uid.mony-moy})")

def main():
count=10000
uid=dict()
while True:
   s=input("1.录入;2.查询;3.升级;4.降级;5.退出:")
   if s=='1':
         uid=create(count)
         uid.salary()
         print(f"录入成功! 姓名:{uid.name},工号:{uid.uid},薪资:{uid.mony} ")
         count +=1
   if s=='2':
         search(uid)
   if s=='3':
         up(uid)
   if s=='4':
         down(uid)
   if s=='5':
         break

屿川发表于 2026-5-17 18:15:07

请回复您的答案^_^

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

第 0 题的答案是：
千人千面
第 1 题的答案是：
灵活，影响小
第 2 题的答案是：
可以
第 3 题的答案是：

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

请将第 0 题的代码写在下方：
member_list = []
class GetMixin:
def get_uid(self):
   uid = input("请输入工号：")
   self.uid = uid

def get_name(self):
   name = input("姓名；")
   self.name = name

def get_job(self):
   job = input("职位（E.普通员工;T.组长;M.经理）：")
   self.job = job

def get_grade(self):
   grade = int(input("级别："))
   self.grade = grade

def get_year(self):
   year = int(input("工龄："))
   self.year = year

def finding(self,uid,member_list):
   for i in member_list:
         if i.uid == uid:
            return i
   print("该工号不存在！")
   return None

class Salary(GetMixin):
def __init__(self):
   pass
def sala(self,e):
   pass
def upper(self,e):
   pass

class Employee(Salary):
def __init__(self):
   super().__init__()

def sala(self,e):
   return 3000 + 500*e.grade + 50*e.year

def upper(self,e):
   if e.grade >= 10:
         e.job = "T"
         e.grade = 1
   elif e.grade <= 0:
         e.job = "E"
         e.grade = 1

class Teamleader(Salary):
def __init__(self):
   super().__init__()

def sala(self,e):
   return 4000 + 800*e.grade + 100*e.year

def upper(self,e):
   if e.grade >= 6:
         e.job = "M"
         e.grade = 1
   elif e.grade <= 0:
         e.job = "E"
         e.grade = 10

class Manager(Salary):
def __init__(self):
   super().__init__()

def sala(self,e):
   return 5000 + 1000*(e.grade + e.year)

def upper(self,e):
   if e.grade >= 3:
         e.job = "M"
         e.grade = 3
   elif e.grade <= 0:
         e.job = "T"
         e.grade = 6

JOB_MAP = {"E":Employee(),"T":Teamleader(),"M":Manager()}

class Member(GetMixin):
uid = 10000
def __init__(self):
   self.uid = str(Member.uid)
   Member.uid += 1
   self.name = ''
   self.job = ''
   self.grade = 1
   self.year = 0
   self.role = None

class Manage(GetMixin):
def welcome(self):
   i = 0
   while i != '5':
         i = input("\n1.录入;2.查询;3.升级;4.降级;5.退出程序：")
         if i == '1':
            self.enter()
         elif i == '2':
            self.find()
         elif i == '3':
            self.up()
         elif i == '4':
            self.low()
         elif i == '5':
            break

def enter(self):
   e = Member()
   e.get_name()
   e.get_job()
   e.get_grade()
   e.get_year()
   e.role = JOB_MAP
   member_list.append(e)
   sal = e.role.sala(e)
   print(f"录入成功！姓名：{e.name},工号：{e.uid},薪资：{sal}")

def find(self):
   o_find = input("1.员工查询；2.职位查询：")
   if o_find == '1':
         uid = input("请输入工号：")
         f = self.finding(uid,member_list)
         if f:
            new_sal = f.role.sala(f)
            print(f"姓名：{f.name}\n职位：{f.job}\n级别：{f.grade}\n工龄：{f.year}")
   else:
         j = input("职位（E.普通员工;T.组长;M.经理）：")
         p = 0
         for n in member_list:
            if n.job == j:
               p += 1
               print(f"目前共有{p}人：\n{n.uid} - {n.name}")

def up(self):
   uid = input("请输入工号：")
   f = self.finding(uid,member_list)
   g = int(input("请输入需要增加的级数："))
   f.grade += g
   f.role.upper(f)
   f.role = JOB_MAP
   new_sal = f.role.sala(f)
   print("升级成功！")
   print(f"{f.name},工号：{f.uid},升级后职位：{f.job}{f.grade},升级后薪资：{new_sal}")

def low(self):
   uid = input("请输入工号：")
   f = self.finding(uid,member_list)
   l = int(input("请输入需要减少的级数："))
   f.grade -= l
   f.role.upper(f)
   f.role = JOB_MAP
   new_sal = f.role.sala(f)
   print("降级成功!")
   print(f"{f.name},工号：{f.uid},降级后职位：{f.job}{f.grade},降级后薪资：{new_sal}")


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

松怪怪 发表于 2026-5-16 20:16:20

请回复您的答案^_^

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

第 0 题的答案是：
针对同一个函数/方法，根据传入的对象不同会有不同的结果

第 1 题的答案是：
可以直接封装好一段代码，然后调用不同类的对象可以实现不同的功能，一段代码就可以实现多种功能

第 2 题的答案是：
可以

第 3 题的答案是：
只要一只鸟走起来像鸭子，叫起来像鸭子，那么它就是鸭子

第 4 题的答案是：
增强了内聚

第 5 题的答案是：
属于，这里相当于传入了不同的对象能够有不同的结果

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

请将第 0 题的代码写在下方：
class Staff:
def __init__(self, uid, name, job, grade, year):
   self.uid = uid
   self.name = name
   self.job = job
   self.grade = grade
   self.year = year
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):
   pass

class Employee(Staff):
def __init__(self, uid, name, job, grade, year):
   super().__init__(uid, name, job, grade, year)
def get_salary(self):
   return 3000+500*self.grade+50*self.year

class Teamleader(Staff):
def __init__(self, uid, name, job, grade, year):
   super().__init__(uid, name, job, grade, year)
def get_salary(self):
   return 4000+800*self.grade+100*self.year

class Manager(Staff):
def __init__(self, uid, name, job, grade, year):
   super().__init__(uid, name, job, grade, year)
def get_salary(self):
   return 5000+1000*(self.grade+self.year)

def enter(staff_lis):
i = 0
while True:
   uid = 10000 + i
   name = input("姓名：")
   job = input("职位（E.普通员工；T.组长；M.经理）：")
   year = int(input("工龄："))
   grade = int(input("级别："))
   if job == "E":
         while grade > 10:
            grade = int(input("该职位最高级别为10，请重新录入级别："))
         staff = Employee(uid, name, job, grade, year)
   elif job == "T":
         while grade > 6:
            grade = int(input("该职位最高级别为6，请重新录入级别："))
         staff = Teamleader(uid, name, job, grade, year)
   elif job == "M":
         while grade > 3:
            grade = int(input("该职位最高级别为3，请重新录入级别："))
         staff = Manager(uid, name, job, grade, year)
   staff_lis.append(staff)
   print(f"录入成功！姓名：{staff.name}，工号：{staff.uid}，薪资：{staff.get_salary()}")
   yield staff
   i += 1

def query(staff_lis):
cmd = int(input("1.员工查询；2.职位查询："))
if cmd == 1:
   uid_q = int(input("请输入工号："))
   sum = 0
   for x in staff_lis:
         if uid_q == x.uid:
            sum += 1
            print("姓名：", x.name)
            print("职位：", x.job)
            print("级别：", x.grade)
            print("工龄：", x.year)
            print("薪资：", x.get_salary())
   if sum == 0:
         print("该工号不存在！")

elif cmd == 2:
   job_dic = {"E":"普通员工", "T":"组长", "M":"经理"}
   job_q = input("职位（E.普通员工；T.组长；M.经理）：")
   job_name = job_dic
   staff_q_lis =
   if len(staff_q_lis) == 0:
         print(f"目前公司没有{job_name}")
   else:
         print(f"目前{job_name}共有{len(staff_q_lis)}人")
         for each in staff_q_lis:
            print(f"{each.uid} - {each.name}")

def up(staff_lis):
uid = int(input("请输入工号："))
sum = 0
for x in staff_lis:
   if x.uid == uid:
         index = staff_lis.index(x)
         sum += 1
         salary_org = x.get_salary()
         print(x.name, "工号：", x.uid, "当前职位：", f"{x.job}", x.grade,
               "当前薪资：", salary_org)
         up_num = int(input("请输入需要增加的级数："))
         level = x.grade + up_num
         if x.job == "E":
            if level > 10:
               x.grade = 1
               x.job = "T"
               staff_lis = Teamleader(x.uid, x.name, x.job, x.grade, x.year)
               x = staff_lis
            else:
               x.grade = level
            print("升级成功！")
         elif x.job == "T":
            if level > 6:
               x.grade = 1
               x.job = "M"
               staff_lis = Manager(x.uid, x.name, x.job, x.grade, x.year)
               x = staff_lis
            else:
               x.grade = level
            print("升级成功！")
         elif x.job == "M":
            if x.grade == 3:
               print("您已到最高级别，无法再升级")
            elif level > 3:
               x.grade = 3
               print("升级成功！")
            else:
               x.grade = level
               print("升级成功！")
         print(x.name, "工号：", x.uid, "升级后职位：", f"{x.job}", x.grade,
               "当前薪资：", x.get_salary(), f"（+{x.get_salary() - salary_org}）")
if sum == 0:
   print("查无此人")

def down(staff_lis):
uid = int(input("请输入工号："))
sum = 0
for x in staff_lis:
   if x.uid == uid:
         index = staff_lis.index(x)
         sum += 1
         salary_org = x.get_salary()
         print(x.name, "工号：", x.uid, "当前职位：", f"{x.job}：", x.grade,
               "薪资：", salary_org)
         down_num = int(input("请输入需要减少的级数："))
         level = x.grade - down_num
         if x.job == "E":
            if level <= 0:
               x.grade = 1
               x.job = "E"
            else:
               x.grade = level
            print("降级成功！")
         elif x.job == "T":
            if level <= 0:
               x.grade = 10
               x.job = "E"
               staff_lis = Employee(x.uid, x.name, x.job, x.grade, x.year)
               x = staff_lis
            else:
               x.grade = level
            print("降级成功！")
         elif x.job == "M":
            if level <= 0:
               x.grade = 6
               x.job = "T"
               staff_lis = Teamleader(x.uid, x.name, x.job, x.grade, x.year)
               x = staff_lis
            else:
               x.grade = level
            print("降级成功！")
         print(x.name, "工号：", x.uid, "升级后职位：", f"{x.job}：", x.grade,
               "薪资：", x.get_salary(), f"（{x.get_salary() - salary_org}）")
if sum == 0:
   print("查无此人")

def main():
staff_lis = []
iterator = enter(staff_lis)
while True:
   command = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
   if command == 1:
         next(iterator)
   elif command == 2:
         query(staff_lis)
   elif command == 3:
         up(staff_lis)
   elif command == 4:
         down(staff_lis)
   elif command == 5:
         break

if __name__ == '__main__':
main()

yuanyeguishu 发表于 2026-5-13 13:51:16

请回复您的答案^_^

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

第 0 题的答案是：
在子类中对父类的方法再次定义
第 1 题的答案是：
减少重复操作可以依次输入根据情况有不同结果
第 2 题的答案是：
可以
第 3 题的答案是：
看着是鸭子.........
第 4 题的答案是：
鸭子类型和其他模块毫无瓜葛只是被顶层调用降低了耦合
第 5 题的答案是：
不是
-------- 动动手 --------

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

斯文0729 发表于 2026-5-12 15:37:53

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

HAHAHABAO 发表于 2026-5-9 21:05:55

nicolu 发表于 2026-5-9 16:47:56

3352925169 发表于 2026-5-9 15:18:14

Wendy_NL 发表于 2026-5-5 21:29:25

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：可以

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

cold-dew-ai 发表于 2026-5-1 17:48:42

请回复您的答案^_^

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

第 0 题的答案是：根据不同的对象执行不同的操作

第 1 题的答案是：减少代码重复

第 2 题的答案是：可以

第 3 题的答案是：看起来像鸭子，吃起来也像，那就是鸭子

第 4 题的答案是：增强内聚

第 5 题的答案是：是

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

请将第 0 题的代码写在下方：
class people:
def __init__(self,name,job,grade,year,uid):
   self.name = name    #姓名
   self.job = job    #职位
   self.grade = grade #级别
   self.year = year    #工龄
   self.uid = uid    #工号
def salary(self):
   if self.job == 'E':
         return 3000 + 500 * int(self.grade) + 50 * int(self.year)
   if self.job == 'T':
         return 4000 + 800 * int(self.grade) + 100 * int(self.year)
   if self.job == 'M':
         return 5000 + 1000 * (int(self.grade) + int(self.year))
def main():
word = {}
uid = 10000
while 1:
   print()
   x = input("1.录入;2.查询;3.升级;4.降级;5.退出：")
   if x == '1':
         name = input("姓名：")
         job = input("职位（E.普通员工;T.组长;M.经理）：")
         year = input("工龄：")
         grade = input("级别：")
         while job == "E" and int(grade) > 10:
            grade = input("该职位最高级别为10，请重新录入级别：")
         while job == "T" and int(grade) > 6:
            grade = input("该职位最高级别为6，请重新录入级别：")
         while job == "M" and int(grade) > 3:
            grade = input("该职位最高级别为3，请重新录入级别：")
         word = people(name,job,grade,year,uid)
         print(f"录入成功！姓名：{name}，工号：{uid}，薪资：{word.salary()}")
         uid += 1
   elif x == '2':
         y = input("1.员工查询;2.职位查询：")
         if y == "1":
            z = input("请输入工号：")
            for i in word:
               if i == z:
                     print(f"姓名：{word.name}")
                     print(f"职位：{word.job}")
                     print(f"级别：{word.grade}")
                     print(f"工龄：{word.year}")
                     print(f"薪资：{word.salary()}")
                     break
            else:
               print("该工号不存在！")
         elif y == "2":
            job = input("职位（E.普通员工;T.组长;M.经理）：")
            while 1:
               num = []
               for i in word:
                     if word.job == job:
                        num.append(i)
               if job == "E":
                     print(f"目前普通员工共有{len(num)}人：")
                     for i in num:
                        print(f"{i} - {word.name}")
                     break
               elif job == "T":
                     print(f"目前组长共有{len(num)}人：")
                     for i in num:
                        print(f"{i} - {word.name}")
                     break
               elif job == "M":
                     print(f"目前经理共有{len(num)}人：")
                     for i in num:
                        print(f"{i} - {word.name}")
                     break
               else:
                     job = input("职位错误！请重新输入职位：")
   elif x == '3':
         y = input("请输入工号：")
         try:
            print(f"{word.name}，工号：{word.uid}，当前职位：{word.job + word.grade}，当前薪资：{word.salary()}")
            z = input("请输入需要增加的级数：")
            if word.job == 'E' and int(word.grade) + int(z) > 10:
               word.job = 'T'
               word.grade = '1'
               print("升级成功！")
            elif word.job == 'T' and int(word.grade) + int(z) > 6:
               word.job = 'M'
               word.grade = '1'
               print("升级成功！")
            elif word.job == 'M' and int(word.grade) + int(z) > 3:
               print("升级失败！经理最高只能为3级")
            else:
               word.grade = str(int(word.grade) + int(z))
            print(f"{word.name}，工号：{word.uid}，升级后职位：{word.job + word.grade}，升级后薪资：{word.salary()}")
         except:
            print("错误！该工号不存在！")
   elif x == '4':
         y = input("请输入工号：")
         try:
            print(f"{word.name}，工号：{word.uid}，当前职位：{word.job + word.grade}，当前薪资：{word.salary()}")
            z = input("请输入需要减少的级数：")
            if word.job == 'E' and int(word.grade) - int(z) < 1:
               word.pop(y)
               print("降级成功！该员工已被辞退！")
            elif word.job == 'T' and int(word.grade) - int(z) < 1:
               word.job = 'E'
               word.grade = '10'
               print("降级成功！")
            elif word.job == 'M' and int(word.grade) - int(z) < 1:
               word.job = 'T'
               word.grade = '6'
               print("降级成功！")
            else:
               word.grade = str(int(word.grade) - int(z))
            print(f"{word.name}，工号：{word.uid}，降级后职位：{word.job + word.grade}，降级后薪资：{word.salary()}")
         except:
            print("错误！该工号不存在！")
   elif x == '5':
         break

M_mm 发表于 2026-4-26 10:37:55

请回复您的答案^_^

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

第 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_year(self):
   return self.year
def get_grade(self):
   return self.grade
def salary(self):
   return 3000 + 500*self.grade +50*self.year
class Teamleader(Employee):
super().__init__()
super().get_uid()
super().get_name()
super().get_job()
super().get_year()
super().get_grade()
def salary(self):
   return 4000 + 800*self.grade + 100*self.year

class Manager(Employee):
super().__init__()
super().get_uid()
super().get_name()
super().get_job()
super().get_year()
super().get_grade()
def salary(self):
   return 5000 + 1000*(self.grade + self.year)

luochaowei 发表于 2026-4-18 17:27:40

2522014507 发表于 2026-4-13 16:07:42

南瓜墩墩 发表于 2026-4-13 10:19:24

yuehh_dyrcj 发表于 2026-4-12 15:49:52

请回复您的答案^_^

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

第 0 题的答案是：
靠鸭子类型（不强制继承 / 接口）
第 1 题的答案是：
让代码更灵活、更好扩展、更易维护，同时减少重复逻辑。
第 2 题的答案是：
可以
第 3 题的答案是：
如果它走起路来像鸭子，叫起来也像鸭子，那它就是鸭子。
第 4 题的答案是：
鸭子类型优先体现为降低耦合，同时有利于高内聚。
第 5 题的答案是：
不是
-------- 动动手 --------

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

huayangshihan 发表于 2026-4-11 17:41:37

zzj375100270 发表于 2026-4-8 16:40:15

请回复您的答案^_^

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

第 0 题的答案是：重写

第 1 题的答案是：更灵活

第 2 题的答案是：可以

第 3 题的答案是：

第 4 题的答案是：内聚

第 5 题的答案是：属于

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

请将第 0 题的代码写在下方：
class Staff:
def __init__(self, uid):
   self.uid = uid
   self.name = ""
   self.job = ""
   self.grade = 0
   self.year = 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 get_year(self):
   return self.year
def get_salary(self):
   return self.salary()
def get_level(self):
   return self.job + str(self.grade)
def salary(self):
   pass

class Employee(Staff):
def __init__(self, uid):
   super().__init__(uid)
   self.job = "E"
def salary(self):
   return 3000 + self.grade * 500 + self.year * 50

class Teamleader(Staff):
def __init__(self, uid):
   super().__init__(uid)
   self.job = "T"
def salary(self):
   return 4000 + self.grade * 800 + self.year * 100

class Manager(Staff):
def __init__(self, uid):
   super().__init__(uid)
   self.job = "M"
def salary(self):
   return 5000 + 1000 * (self.grade + self.year)

class Management:
def __init__(self):
   self.staffs = []
   self.uid = 10000

def add_staff(self):
   name = input("姓名：")
   if not name:
         print("姓名不能为空！")
         return

   job = input("职位（E.普通员工;T.组长;M.经理）：")
   if job not in ["E", "T", "M"]:
         print("职位输入错误！")
         return

   if job == "E":
         staff = Employee(self.uid)
   elif job == "T":
         staff = Teamleader(self.uid)
   else:
         staff = Manager(self.uid)

   staff.name = name

   while True:
         try:
            year = int(input("工龄："))
            if year < 0:
               print("工龄不能为负数！")
               continue
            break
         except ValueError:
            print("请输入正确的数字！")
   staff.year = year

   job_grade_max = {"E": 10, "T": 6, "M": 3}
   while True:
         try:
            grade = int(input("级别："))
            if grade < 1 or grade > job_grade_max:
               print(f"级别输入错误！{job_grade_max}级为最高级别")
               continue
            break
         except ValueError:
            print("请输入正确的数字！")
   staff.grade = grade

   self.staffs.append(staff)
   self.uid += 1
   print(f"录入成功！姓名：{staff.name}，工号：{self.uid-1}，薪资：{staff.get_salary()}")

def staff_search(self):
   while True:
         try:
            uid = int(input("请输入工号："))
            break
         except ValueError:
            print("请输入正确的数字！")

   found = False
   for staff in self.staffs:
         if staff.get_uid() == uid:
            print(f"姓名：{staff.get_name()}")
            print(f"职位：{staff.get_job()}")
            print(f"级别：{staff.get_grade()}")
            print(f"工龄：{staff.get_year()}")
            print(f"薪资：{staff.get_salary()}")
            found = True
            break
   if not found:
         print("该工号不存在！")
         return

def job_search(self):
   level_lst = {"E":"普通员工","T":"组长","M":"经理"}
   job = input("职位（E.普通员工;T.组长;M.经理）：")
   if job not in level_lst:
         print("职位输入错误！")
         return

   staff_lst = []
   staff_count = 0
   for staff in self.staffs:
         if staff.get_job() == job:
            staff_lst.append(staff)
            staff_count += 1
   if staff_count == 0:
         print(f"目前公司没有{level_lst}！")
         return
   else:
         print(f"目前{level_lst}共有{staff_count}人：")
         for staff in staff_lst:
            print(f"{staff.uid} - {staff.name}")

def search(self):
   choice = input("1.员工查询;2.职位查询：")
   if choice == "1":
         self.staff_search()
   elif choice == "2":
         self.job_search()
   else:
         print("查询类型输入错误！")
         return

def level_up(self):
   while True:
         try:
            uid = int(input("请输入工号："))
            break
         except ValueError:
            print("请输入正确的数字！")

   found = False
   for staff in self.staffs:
         if staff.get_uid() == uid:
            print(f"{staff.get_name()}，工号：{staff.get_uid()}，当前职位：{staff.get_level()}，当前薪资：{staff.get_salary()}")
            found = True
            break
   if not found:
         print("该工号不存在！")
         return

   while True:
         try:
            increase_level = int(input("请输入需要增加的级数："))
            if increase_level < 1:
               print("增加级数必须大于0！")
               continue
            break
         except ValueError:
            print("请输入正确的数字！")

   job_grade_max = {"E": 10, "T": 6, "M": 3}
   current_job = staff.get_job()
   current_grade = staff.get_grade()
   new_grade = current_grade + increase_level

   if new_grade <= job_grade_max:
         staff.grade = new_grade
         print(f"升级成功！")
         print(f"{staff.get_name()}，工号：{staff.get_uid()}，升级后职位：{staff.get_level()}，升级后薪资：{staff.get_salary()}")
   else:
         if current_job == "M":
            print("已经是最高职位，无法继续升职！")
            return
         if current_job == "E":
            new_staff = Teamleader(staff.uid)
         else:
            new_staff = Manager(staff.uid)
         new_staff.name = staff.get_name()
         new_staff.year = staff.get_year()
         new_staff.grade = 1
         old_salary = staff.get_salary()
         new_salary = new_staff.get_salary()
         change = new_salary - old_salary
         idx = self.staffs.index(staff)
         self.staffs = new_staff
         print("升级成功！")
         print(f"{new_staff.name}，工号：{new_staff.uid}，升级后职位：{new_staff.get_level()}，升级后薪资：{new_salary}({change:+.0f})")

def level_down(self):
   while True:
         try:
            uid = int(input("请输入工号："))
            break
         except ValueError:
            print("请输入正确的数字！")

   found = False
   for staff in self.staffs:
         if staff.get_uid() == uid:
            print(f"{staff.get_name()}，工号：{staff.get_uid()}，当前职位：{staff.get_level()}，当前薪资：{staff.get_salary()}")
            found = True
            break
   if not found:
         print("该工号不存在！")
         return

   while True:
         try:
            demote_level = int(input("请输入需要减少的级数："))
            if demote_level < 1:
               print("减少级数必须大于0！")
               continue
            break
         except ValueError:
            print("请输入正确的数字！")

   job_grade_max = {"E": 10, "T": 6, "M": 3}
   current_job = staff.get_job()
   current_grade = staff.get_grade()
   new_grade = current_grade - demote_level

   if new_grade >= 1:
         staff.grade = new_grade
         print("降级成功！")
         print(f"{staff.get_name()}，工号：{staff.get_uid()}，降级后职位：{staff.get_level()}，降级后薪资：{staff.get_salary()}")
   else:
         if current_job == "E":
            print("已经是最低职位，无法继续降职！")
            return
         if current_job == "T":
            new_staff = Employee(staff.uid)
         else:
            new_staff = Teamleader(staff.uid)
         new_staff.name = staff.get_name()
         new_staff.year = staff.get_year()
         new_staff.grade = job_grade_max
         old_salary = staff.get_salary()
         new_salary = new_staff.get_salary()
         change = new_salary - old_salary
         idx = self.staffs.index(staff)
         self.staffs = new_staff
         print("降级成功！")
         print(f"{new_staff.name}，工号：{new_staff.uid}，升级后职位：{new_staff.get_level()}，升级后薪资：{new_salary}({change:+.0f})")

def main():
manage = Management()
while True:
   print("1.录入;2.查询;3.升级;4.降级;5.退出：")
   choice = input("请输入您的选择：")
   if choice == "1":
         manage.add_staff()
   elif choice == "2":
         manage.search()
   elif choice == "3":
         manage.level_up()
   elif choice == "4":
         manage.level_down()
   elif choice == "5":
         print("谢谢使用！")
         break
   else:
         print("选择输入错误！")

页: 1 2 3 [4] 5 6 7 8 9 10 11 12 13

鱼C论坛's Archiver