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

jikfg 发表于 2026-6-2 15:55:13

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

Szn1991 发表于 2026-6-1 09:13:03

请回复您的答案^_^

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

第 0 题的答案是：
对于同一个运算符、函数或对象在不同的场景下，具有不同的作用效果。
第 1 题的答案是：
减少重复的定义函数。
第 2 题的答案是：
可以。
第 3 题的答案是：
不知道。
第 4 题的答案是：
降低了耦合度。
第 5 题的答案是：
不属于。
-------- 动动手 --------

请将第 0 题的代码写在下方：
class Employee:
def __init__(self,name,job,grade,year,uid,salary):
   self.name = name
   self.job = job
   self.grade = grade
   self.year = year
   self.uid = uid
   self.salary = salary
class Salary_calculate:
def calculate(self,job,grade,year):
   if job == 'M':
         salary = 5000 + 1000 * (int(grade) + int(year))
   elif job == 'T':
         salary = 4000 + 800 * int(grade) + 100 * int(year)
   elif job == 'E':
         salary = 3000 + 500 * int(grade) + 50 * int(year)
   else:
         raise ValueError("输入的数据无效。")
   return salary

class Management(Salary_calculate):
def __init__(self):
   self.date = {}
   self.uid = 10000

def welcome(self):
   ins = 0
   while ins != '5':
         ins = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
         if ins == '1':
            self.createmployee()
         elif ins == '2':
            result = self.find()
            if result == 1:
               print("该工号不存在！")
         elif ins == '3':
            self.upgrade()
         elif ins == '4':
            self.downgrade()
         elif ins == '5':
            print()

def createmployee(self):
   name = input("姓名：")
   job = input("职位（E.普通员工；T.组长；M.经理）：")
   year = input("工龄：")
   grade = input("级别：")
   if job == 'E' and int(grade) > 10:
         grade = input("该职位最高级别为10，请重新录入级别：")
   elif job == 'T' and int(grade) > 6:
         grade = input("该职位最高级别为6，请重新录入级别：")
   elif job == 'M' and int(grade) > 3:
         grade = input("该职位最高级别为3，请重新录入级别：")
   salary = self.calculate(job,grade,year)
   employee = Employee(name, job, grade, year, self.uid,salary)
   self.date = employee
   print(f"录入成功！姓名：{name},工号：{self.uid},薪资：{salary}")
   self.uid += 1

def find(self):
   s = input("1.员工查询；2.职位查询：")
   if s == '1':
         uid = int(input("请输入工号："))
         if uid not in self.date.keys():
            return 1
         print(f"姓名：{self.date.name}")
         print(f"职位：{self.date.job}")
         print(f"级别：{self.date.grade}")
         print(f"工龄：{self.date.year}")
         print(f"薪资：{self.date.salary}")
   if s == '2':
         count1 = 0
         date1 = {}
         job = input("职位（E.普通员工；T.组长；M.经理）：")
         if job == 'E':
            for i in self.date.values():
               if i.job == 'E':
                     date1 = i.name
                     count1 += 1
            if count1 != 0:
               print(f"目前普通员工共有{count1}人：")
               for x,y in date1.items():
                     print(f"{x} - {y}")
            else:
               print("目前公司没有普通员工！")

         if job == 'T':
            for i in self.date.values():
               if i.job == 'T':
                     date1 = i.name
                     count1 += 1
            if count1 != 0:
               print(f"目前组长共有{count1}人：")
               for x, y in date1.items():
                     print(f"{x} - {y}")
            else:
               print("目前公司没有组长！")
         if job == 'M':
            for i in self.date.values():
               if i.job == 'M':
                     date1 = i.name
                     count1 += 1
            if count1 != 0:
               print(f"目前经理共有{count1}人：")
               for x, y in date1.items():
                     print(f"{x} - {y}")
            else:
               print("目前公司没有经理！")

def upgrade(self):
   uid = int(input("请输入工号："))
   print(f"{self.date.name}，工号：{uid}，当前职位：{self.date.job}{self.date.grade}，当前薪资：{self.date.salary}")
   salary1 = self.date.salary
   grade1 = int(input("请输入需要增加的级数："))
   t1 = str(int(self.date.grade) + int(grade1))
   if self.date.job == 'E':
         if int(self.date.grade) + int(grade1) <= 10:
            self.date.grade = t1
            self.date.salary = self.calculate(self.date.job, self.date.grade, self.date.year)
         else:
            self.date.grade = '1'
            self.date.job = 'T'
            self.date.salary = self.calculate(self.date.job,self.date.grade,self.date.year)
         print(f"升级成功！\n{self.date.name}，工号：{uid}，升级后的职位：{self.date.job}{self.date.grade}，升级后薪资：{self.date.salary}({self.date.salary - salary1})")
         returnNone
   if self.date.job == 'T':
         if int(self.date.grade) + int(grade1) <= 6:
            self.date.grade = t1
            self.date.salary = self.calculate(self.date.job, self.date.grade, self.date.year)
         else:
            self.date.grade = '1'
            self.date.job = 'M'
            self.date.salary = self.calculate(self.date.job,self.date.grade,self.date.year)
         print(f"升级成功！\n{self.date.name}，工号：{uid}，升级后的职位：{self.date.job}{self.date.grade}，升级后薪资：{self.date.salary}(+{self.date.salary - salary1})")
         return None
   if self.date.job == 'M':
         if int(self.date.grade) + int(grade1) <= 3:
            self.date.grade = t1
            self.date.salary = self.calculate(self.date.job, self.date.grade, self.date.year)
         else:
            self.date.grade = '3'
            self.date.salary = self.calculate(self.date.job,self.date.grade,self.date.year)
         print(f"升级成功！\n{self.date.name}，工号：{uid}，升级后的职位：{self.date.job}{self.date.grade}，升级后薪资：{self.date.salary}({self.date.salary - salary1})")
         return None

def downgrade(self):
   uid = int(input("请输入工号："))
   print(f"{self.date.name}，工号：{uid}，当前职位：{self.date.job}{self.date.grade}，当前薪资：{self.date.salary}")
   salary1 = self.date.salary
   grade1 = int(input("请输入需要减少的级数："))
   t2 = str(int(self.date.grade) - int(grade1))
   if self.date.job == 'E':
         if int(self.date.grade) - int(grade1) > 1:
            self.date.grade = t2
            self.date.salary = self.calculate(self.date.job, self.date.grade, self.date.year)
         else:
            self.date.grade = '1'
            self.date.salary = self.calculate(self.date.job, self.date.grade, self.date.year)
         print(f"降级成功！\n{self.date.name}，工号：{uid}，降级后的职位：{self.date.job}{self.date.grade}，降级后薪资：{self.date.salary}({self.date.salary - salary1})")
         return None
   if self.date.job == 'T':
         if int(self.date.grade) - int(grade1) > 1:
            self.date.grade = t2
            self.date.salary = self.calculate(self.date.job, self.date.grade, self.date.year)
         else:
            self.date.grade = '10'
            self.date.job = 'E'
            self.date.salary = self.calculate(self.date.job, self.date.grade, self.date.year)
         print(f"降级成功！\n{self.date.name}，工号：{uid}，降级后的职位：{self.date.job}{self.date.grade}，降级后薪资：{self.date.salary}({self.date.salary - salary1})")
         return None
   if self.date.job == 'M':
         if int(self.date.grade) - int(grade1) > 1:
            self.date.grade = t2
            self.date.salary = self.calculate(self.date.job, self.date.grade, self.date.year)
         else:
            self.date.grade = '6'
            self.date.job = 'T'
            self.date.salary = self.calculate(self.date.job, self.date.grade, self.date.year)
         print(f"降级成功！\n{self.date.name}，工号：{uid}，降级后的职位：{self.date.job}{self.date.grade}，降级后薪资：{self.date.salary}({self.date.salary - salary1})")
         return None

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

main()

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

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

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

鱼C论坛's Archiver