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

zhangjiepython 发表于 2025-3-4 09:10:12

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

大圣乐 发表于 2025-2-28 09:37:26

小清和 发表于 2025-2-24 22:49:15

请回复您的答案^_^

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

第 0 题的答案是：python是一门动态的编程语言，当同一个函数，方法在不同形势下可能有不同作用

第 1 题的答案是：让一个函数，方法充分发挥他的作用

第 2 题的答案是：可以

第 3 题的答案是：

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

第 5 题的答案是：不是多态现象，2.3.4都是数字，没有换种类型

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

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

class Logger():
def get_uid(self):
   member_number = {}

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

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

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

def get_grade(self):
   grade = input("级别：")
   if job == E:
         while grade > 10:
            grade = input("该职位最高级别为10，请重新输入：")

wdoxsxwd 发表于 2025-2-24 20:42:27

请回复您的答案^_^

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

第 0 题的答案是：方法重写

第 1 题的答案是：提高了代码的灵活性和可扩展性

第 2 题的答案是：可以

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：不属于

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

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

s_py 发表于 2025-2-24 15:22:22

yhylzjnx 发表于 2025-2-21 15:14:17

Zzh159 发表于 2025-2-20 16:07:40

请回复您的答案^_^

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

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

第 1 题的答案是：在不同的对象中，属性和能力可以被改写

第 2 题的答案是：

第 3 题的答案是：我们不需要关心对象的具体类型，只需关注其行为方法是否符合即可

第 4 题的答案是：

第 5 题的答案是：是

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

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

andreahhhhhh 发表于 2025-2-18 10:51:58

谪仙ovo 发表于 2025-2-17 18:25:00

xiehongzhe 发表于 2025-2-17 16:16:03

请回复您的答案^_^

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

第 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 Company:
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:
def count(self,job,grade,year):
   if job == "E":
         salary = 3000 + 500*grade +50*year
   elif job == "T":
         salary = 4000 + 800*grade +100*year
   elif job == "M":
         salary = 5000 + 1000*(year+grade)
   return salary

class Manage(Company,Salary):
def __init__(self):
   self.messages = {}
   self.employee = 0
   self.teamleader = 0
   self.manager = 0
   self.uid = 10000
   self.grade_ = {"E":10,"T":6,"M":3}
def welcome(self):
   while True:
         _ = input("1.录入;2.查询;3.升级;4.降级;5.退出:")
         if _ == "1":
            self.entering()
         if _ == "2":
            self.inquire()
         if _ == "3":
            self.upgrade()
         if _ == "4":
            self.downgrade()
         if _ == "5":
            break

def grade_amend(self,job):
   grade = int(input("级别："))
   while True:
         if grade > self.grade_:
            grade = int(input(f"职位最高级别为{self.grade_},请重新输入级别:"))
         else:
            break
   return grade

def entering(self):
   name = input("姓名：")
   job = input("职位（E.普通员工；T.组长；M.经理）：")
   year = int(input("工龄："))
   grade = self.grade_amend(job)
   salary = self.count(job,grade,year)
   if job == "E":
         self.employee += 1
   elif job == "T":
         self.teamleader += 1
   elif job == "M":
         self.manager += 1
   company = Company(name,job,grade,year,self.uid,salary)
   self.messages = company
   print(f"录入成功！姓名：{name},工号：{self.uid},薪资:{salary}")
   self.uid += 1

def inquire(self):
   ins = input("1.员工查询;2.职位查询：")
   if ins == "1":
         x = int(input("请输入工号："))
         if self.messages.get(x) == None:
            print("该工号不存在!")
         else :
            print(f"姓名：{self.messages.name}")
            print(f"职位：{self.messages.job}")
            print(f"级别:{self.messages.grade}")
            print(f"工龄:{self.messages.year}")
            print(f"薪资：{self.messages.salary}")
   elif ins == "2":
         y = input("职位（E.普通员工；T.组长；M.经理）：")
         if y == "E":
            if self.employee == 0 :
               print("目前公司没有普通员工！")
            else:
               print(f"目前普通员工共有{self.employee}人")
               for each in self.messages.keys():
                     if self.messages.job == "E":
                        print(f"{each}-{self.messages.name}")
         elif y == "T":
            if self.teamleader == 0:
               print("目前公司没有组长！")
            else:
               print(f"目前组长共有{self.teamleader}人")
               for each in self.messages.keys():
                     if self.messages.job == "T":
                        print(f"{each}-{self.messages.name}")
         elif y == "M":
            if self.manager == 0:
               print("目前公司没有经理！")
            else:
               print(f"目前经理共有{self.manager}人")
               for each in self.messages.keys():
                     if self.messages.job == "M":
                        print(f"{each}-{self.messages.name}")


def upgrade(self):
   x = int(input("请输入工号："))
   if self.messages.get(x) == None:
         print("该工号不存在!")
   else :
         print(f"{self.messages.name},工号：{x},当前职位:{self.messages.job}{self.messages.grade},当前薪资:{self.messages.salary}")
         old_salary = self.messages.salary
         num = int(input("请输入需要增加的级数："))
         if self.messages.job == "E":
            if self.messages.grade +num <= 10:
               self.messages.grade += num
            else:
               self.messages.grade =1
               self.messages.job = "T"
               self.employee -= 1
               self.teamleader += 1
         elif self.messages.job == "T":
            if self.messages.grade +num <= 6:
               self.messages.grade += num
            else:
               self.messages.grade =1
               self.messages.job = "M"
               self.teamleader -= 1
               self.manager += 1
         elif self.messages.job == "M":
            if self.messages.grade +num <= 3:
               self.messages.grade += num
            else:
               self.messages.grade =3

         print("升级成功！")
         self.messages.salary = self.count(self.messages.job,self.messages.grade,self.messages.year)
         print(f"{self.messages.name},工号：{self.messages.uid},升级后职位：{self.messages.job}{self.messages.grade},升级后薪资:{self.messages.salary}(+{self.messages.salary-old_salary})")

def downgrade(self):
   x = int(input("请输入工号："))
   if self.messages.get(x) == None:
         print("该工号不存在!")
   else :
         print(f"{self.messages.name},工号：{x},当前职位:{self.messages.job}{self.messages.grade},当前薪资:{self.messages.salary}")
         old_salary = self.messages.salary
         num = int(input("请输入需要减少的级数："))
         if self.messages.job == "E":
            if self.messages.grade - num <= 0:
               self.messages.grade = 1
            else:
               self.messages.grade = self.messages.grade - num

         elif self.messages.job == "T":
            if self.messages.grade - num <= 0:
               self.messages.grade = 10
               self.messages.job = "E"
               self.employee += 1
               self.teamleader -= 1
            else:
               self.messages.grade -= num

         elif self.messages.job == "M":
            if self.messages.grade - num <= 0:
               self.messages.grade = 6
               self.messages.job = "T"
               self.teamleader += 1
               self.manager -= 1
            else:
               self.messages.grade -= num

         print("降级成功！")
         self.messages.salary = self.count(self.messages.job,self.messages.grade,self.messages.year)
         print(f"{self.messages.name},工号：{self.messages.uid},降级后职位：{self.messages.job}{self.messages.grade},降级后薪资:{self.messages.salary}(-{old_salary-self.messages.salary})")

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

huanggq 发表于 2025-2-16 13:32:55

请回复您的答案^_^

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

第 0 题的答案是：
同一个接口传入不同参数时返回不同结果
第 1 题的答案是：

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

第 4 题的答案是：
降低耦合
第 5 题的答案是：
没有
-------- 动动手 --------

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

class User:
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):
      print("工号：", self.uid)

def get_name(self):
   print("姓名：",self.name)

def get_job(self):
   print("职位：",self.job)

def get_grade(self):
   print("级别：", self.grade)

def get_year(self):
   print("年限：",self.year)

def salary(self):
   if self.job == "E":
         return 3000 + (500*self.grade) + (50*self.year)
   if self.job == "T":
         return 4000 + (800 * self.grade) + (100 * self.year)
   if self.job == "M":
         return 5000 + (1000 * (self.grade + self.year))

class Employee:
def grade(self):
   g = int(input("级别："))
   while g > 10 or g < 1:
         print("该级别最低为1级，最高为10级，请重新录入：",end=" ")
         g = int(input())
   return g

class Teamleader:
def grade(self):
   g = int(input("级别："))
   while g > 6 or g < 1:
         print("该级别最低为1级，最高为6级，请重新录入：", end=" ")
         g = int(input())
   return g

class Manager:
def grade(self):
   g = int(input("级别："))
   while g > 3 or g < 1:
         print("该级别最低为1级，最高为3级，请重新录入：", end=" ")
         g = int(input())
   return g

class UpMixin:
def up(self,job,leve):
   x = int(input("输入增加的级数："))
   l = x + leve
   if job == "E":
         if l > 10:
            return "T", 1
         else:
            return "E", l
   if job == "T":
         if l > 6:
            return "M", 1
         else:
            return "T", l
   if job == "M":
         if l > 3:
            return "M", 3
         else:
            return "M", l

class Manger(UpMixin):

def __init__(self):
   self.user_list = []
   self.uid = 10000
   self.E = Employee()
   self.T = Teamleader()
   self.M = Manager()

def j(self, x):
   if x == "E":
         return self.E.grade()
   if x == "T":
         return self.T.grade()
   if x == "M":
         return self.M.grade()

def new_user(self):
   """
   录入员工信息
   :return:
   """
   if len(self.user_list) == 0:
         uid = self.uid
         name = input("姓名：")
         job = input("职位：(E、普通员工T、组长M、经理)：")
         grade = self.j(job)
         year = int(input("工龄："))
   else:
         uid = self.user_list[-1].uid +1
         name = input("姓名：")
         job = input("职位：(E、普通员工T、组长M、经理)：")
         grade = self.j(job)
         year = int(input("工龄："))

   self.user_list.append(User(uid, name, job, grade, year))
   print(f"录入完成：姓名{name}，工号：{uid}，职位：{job}，等级：{grade}，工龄：{year}，薪资{self.user_list[-1].salary()}")
   print(self.look())

def look_user(self):
   print("1、员工查询2、职位查询")
   x = input()
   if x == "1":
         number = int(input("输入工号"))
         found = False
         for i in self.user_list:
            if number == i.uid:
               i.get_name()
               i.get_job()
               i.get_grade()
               i.get_year()
               print("薪资：", i.salary())
               found = True
               break
         if not found:
            print("员工不存在")
   if x == "2":
         j = input("职位：(E、普通员工T、组长M、经理)：")
         j_list = []
         count = 0
         for i in self.user_list:
            if j == i.job:
               count += 1
               j_list.append((i.uid,i.name))
         print(f"共有{count}人")
         print(j_list)

def user_up(self):
   number = int(input("输入工号"))
   found = False
   for i in self.user_list:
         if number == i.uid:
            i.get_name()
            i.get_job()
            i.get_grade()
            i.get_year()
            print("薪资：", i.salary())
            j,g = self.up(i.job, i.grade)
            i.grade = g
            i.job = j
            self.look()
            print("升级后：")
            i.get_name()
            i.get_job()
            i.get_grade()
            i.get_year()
            print("薪资：", i.salary())
            break
   else:
         print("用户不存在")

def look(self):
   for i in self.user_list:
         print(i.__dict__)

manger = Manger()

while True:
print("1、录入 2、查看 3、升级 4、降级 5、退出")
x = input()
if x == "1":
   manger.new_user()
if x == "2":
   manger.look_user()

if x == "3":
   manger.user_up()

if x == "5":
   break

hilizzie 发表于 2025-2-11 17:23:34

吃饭睡觉想进步 发表于 2025-2-11 13:53:56

请回复您的答案^_^

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

第 0 题的答案是：Python通过方法重写和鸭子类型实现多态，允许不同类的对象对同一方法做出不同的响应，而不需要显式继承或类型检查。

第 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 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)

class Manage:
def __init__(self):
   self.uid=10000
   self.all_Employee={}
   self.E={}
   self.T={}
   self.M={}
def func(self):
   a=0
   while a!='5':
         a=input("\n1.录入；2.查询；3.升级；4.降级；5.退出：")
         if a=="1":
            self.create()
         if a=='2':
            self.search()
         if a in ("3","4"):
            self.change_grade(a)
         if a=="5":
            break
def create(self):
   name=input("姓名：")
   job=input("职位（E.普通员工；T.组长；M.经理）：")
   year=int(input("工龄："))
   grade=int(input("级别："))
   if job=="E":
         while grade>10:
            grade=int(input("该职位最高级别为10，请重新录入级别："))
         e=Employee(name,job,grade,year,self.uid)
         s=e.salary()
         self.E=e
   if job=="T":
         while grade>6:
            grade=int(input("该职位最高级别为6，请重新录入级别："))
         e=Teamleader(name,job,grade,year,self.uid)
         s=e.salary()
         self.T=e
   if job=="M":
         while grade>3:
            grade=int(input("该职位最高级别为3，请重新录入级别："))
         e=Manager(name,job,grade,year,self.uid)
         s=e.salary()
         self.M=e
   self.all_Employee=e
   print(f"录入成功！姓名：{name},工号：{self.uid},薪资：{s}")
   self.uid+=1
def search(self):
   b=input("1.员工查询；2.职位查询：")

   if b=='1':
         uid=int(input("请输入工号"))
         if uid not in self.all_Employee:
            print("该工号不存在！")
         else:
            x=self.all_Employee
            print(f"姓名：{x.name}\n职位：{x.job}\n级别：{x.grade}\n工龄：{x.year}\n薪资：{x.salary()}")
   if b=='2':
         c=input("职位（E.普通员工；T.组长；M.经理）：")
         if c=="E":
            num=len(self.E)
            if num==0:
               print("目前公司没有普通员工！")
            else:
               print(f"目前普通员工有{num}人：")
            for i in self.E:
               print(f"{i} - {self.E.name}")
         if c=="T":
            num=len(self.T)
            if num==0:
               print("目前公司没有组长！")
            else:
               print(f"目前普通员工有{num}人：")
            for i in self.T:
               print(f"{i} - {self.T.name}")
         if c=="M":
            num=len(self.M)
            if num==0:
               print("目前公司没有经理！")
            else:
               print(f"目前普通员工有{num}人：")
            for i in self.M:
               print(f"{i} - {self.M.name}")
def change_grade(self,a):
   uid=int(input("请输入工号:"))
   if uid not in self.all_Employee:
         print("该工号不存在！")
   info=self.all_Employee
   print(f"{info.name},工号：{uid},当前职位：{info.job}{info.grade},当前薪资{info.salary()}")
   rs=info.salary()
   if a=='4':
         dgrade=int(input("请输入需要减少的级数："))
         if info.job=="E":
            if (info.grade-dgrade)<0:
               ngrade=1
               e=Employee(info.name,"E",ngrade,info.year,uid)
               self.E=e
            else:
               ngrade=(info.grade-dgrade)
               e=Employee(info.name,"E",ngrade,info.year,uid)
               self.E=e
         if info.job=="T":
            if (info.grade-dgrade)<0:
               ngrade=10
               e=Employee(info.name,"E",ngrade,info.year,uid)
               self.E=e
               del self.T
            else:
               ngrade=(info.grade-dgrade)
               e=Teamleader(info.name,"T",ngrade,info.year,uid)
               self.T=e
         if info.job=="M":
            if (info.grade-dgrade)<0:
               ngrade=6
               e=Teamleader(info.name,"T",ngrade,info.year,uid)
               self.T=e
               del self.M
            else:
               ngrade=(info.grade-dgrade)
               e=Manager(info.name,"M",ngrade,info.year,uid)
               self.M=e
         self.all_Employee=e
         s=e.salary()
         print("降级成功！")
         print(f"{e.name},工号：{uid},降级后的职位：{e.job}{str(e.grade)}，降级后的薪资：{s}({s-rs})")
   if a=='3':
         igrade=int(input("请输入需要增加的级数："))
         if info.job=="E":
            if info.grade+igrade>10:
               ngrade=1
               e=Teamleader(info.name,"T",ngrade,info.year,uid)
               self.T=e
               del self.E
            else:
               ngrade=info.grade+igrade
               e=Employee(info.name,info.job,ngrade,info.year,uid)
               self.E=e
         if info.job=="T":
            if info.grade+igrade>6:
               ngrade=1
               e=Manager(info.name,"M",ngrade,info.year,uid)
               self.M=e
               del self.T
            else:
               ngrade=info.grade+igrade
               e=Teamleader(info.name,info.job,ngrade,info.year,uid)
               self.T=e
         if info.job=="M":
            if info.grade+igrade>3:
               ngrade=3
               e=Manger(info.name,"M",ngrade,info.year,uid)
               self.M=e
            else:
               ngrade=info.grade+igrade
               e=Manager(info.name,"M",ngrade,info.year,uid)
               self.M=e
         self.all_Employee=e
         s=e.salary()
         print("升级成功！")
         print(f"{e.name}，工号：{uid}，升级后的职位：{e.job}{str(e.grade)}，升级后的薪资：{s}(+{s-rs})")

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

pyzyd 发表于 2025-2-7 19:57:44

请回复您的答案^_^

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

第 0 题的答案是：通过继承、方法重写和鸭子类型，实现了面向对象的多态特性

第 1 题的答案是：通过允许不同的对象对同一消息做出不同的响应，提供了代码的灵活性和可扩展性，同时也提高了代码的可重用性、可读性和可维护性。

第 2 题的答案是：不对

第 3 题的答案是：If it walks like a duck and quacks like a duck, then it must be 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
   self.salarys = self.salary()

def get_uid(self):
   return 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 get_salary(self):
   print(f"薪资：{self.salarys}")

def salary(self):
   if self.job == 'E':
         s = 3000 + 500 * self.grade + 50 * self.year
   elif self.job == 'T':
         s = 4000 + 800 * self.grade + 100 * self.year
   elif self.job == 'M':
         s = 5000 + 1000 * (self.grade + self.year)
   return s

class EmployeeManageSystem:
def __init__(self):
   self.employee_list = []
   self.grade_dict = {'E': 10, 'T': 6, 'M': 3}

def add_employee(self):
   name = input("姓名：")
   job = input("职位（E.普通员工;T.组长;M.经理）：")
   year = int(input("工龄："))
   grade = int(input("级别："))

   while grade > self.grade_dict:
         grade = int(input(f"该职位最高级别为{self.grade_dict}，请重新录入级别："))
   uid = 10000 + len(self.employee_list)
   self.employee_list.append(Employee(name, job, grade, year, uid))
   salary = self.employee_list[-1].salarys
   print(f"录入成功！姓名：{name}，工号：{uid}，薪资：{salary}")

def inquire_employee(self):
   method = input("1.员工查询;2.职位查询：")
   if method == "1":
         inquire_uid = int(input("请输入工号："))
         for employee in self.employee_list:
            if employee.uid == inquire_uid:
               employee.get_name()
               employee.get_job()
               employee.get_grade()
               employee.get_year()
               employee.get_salary()
               break
         else:
            print("该工号不存在！")

   elif method == "2":
         job_map = {'E':"普通员工",'T':"组长",'M':"经理"}
         inquire_job = input("职位（E.普通员工;T.组长;M.经理）：")
         emps = []
         for employee in self.employee_list:
            if employee.job == inquire_job:
               emps.append(employee)
         print(f"目前{job_map}共有 {len(emps)} 人：")
         if emps:
            for employee in emps:
               print(f"{employee.uid} - {employee.name}")
         else:
            print(f"目前公司没有{job_map}！")

def upgrades(self):
   upgrade_uid = int(input("请输入工号："))
   for employee in self.employee_list:
         if employee.uid == upgrade_uid:
            print(f"{employee.name}，工号：{employee.uid}，当前职位：{employee.job}{employee.grade}，当前薪资：{employee.salarys}")
            salary = employee.salarys
            var_grade = int(input("请输入需要增加的级数："))
            employee.grade += var_grade
            if employee.grade > self.grade_dict:
               employee.grade = 1
               if employee.job == 'E':
                     employee.job = 'T'
               elif employee.job == 'T':
                     employee.job = 'M'
            print("升级成功！")
            employee.salarys = employee.salary()
            print(f"{employee.name}，工号：{employee.uid}，升级后职位：{employee.job}{employee.grade}，升级后薪资：{employee.salarys}（{employee.salarys - salary:+}）")
            break
   else:
         print("该工号不存在！")
def downgrades(self):
   downgrade_uid = int(input("请输入工号："))
   for employee in self.employee_list:
         if employee.uid == downgrade_uid:
            print(f"{employee.name}，工号：{employee.uid}，当前职位：{employee.job}{employee.grade}，当前薪资：{employee.salarys}")
            salary = employee.salarys
            var_grade = int(input("请输入需要减少的级数："))
            employee.grade -= var_grade
            if employee.grade < 0:
               if employee.job == 'M':
                     employee.job = 'T'
               elif employee.job == 'T':
                     employee.job = 'E'
               employee.grade = self.grade_dict
            print("降级成功！")
            employee.salarys = employee.salary()
            print(f"{employee.name}，工号：{employee.uid}，降级后职位：{employee.job}{employee.grade}，降级后薪资：{employee.salarys}（{employee.salarys - salary:+}）")
            break
   else:
         print("该工号不存在！")

def main():
emp_manage = EmployeeManageSystem()
while True:
   menu = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
   if not menu:
         continue
   if menu == '5':
         break

   elif menu == '1':
         emp_manage.add_employee()

   elif menu =='2':
         emp_manage.inquire_employee()

   elif menu == '3':
         emp_manage.upgrades()

   elif menu =='4':
         emp_manage.downgrades()

main()

zhuanghli 发表于 2025-2-1 00:20:13

请回复您的答案^_^

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

第 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 Attribution:
def __init__(self, uid, name, job, grade, year, salary):
   self.get_uid = uid
   self.get_name = name
   self.get_job = job
   self.get_grade = grade
   self.get_year = year
   self.salary = salary

class Manage:
def __init__(self):
   self.employee = {}
   self.teamleader = {}
   self.manager = {}
   self.uid = 10000

def salary(self, job, grade, year):
   if job == 'E':
         return 3000 + 500 * grade + 50 * year
   elif job == 'T':
         return 4000 + 800 * grade + 100 * year
   elif job == 'M':
         return 5000 + 1000 * (grade + year)

def ingrade(self, job):
   grade = int(input("级别："))
   if job == 'E':
         while grade < 1 or grade > 10:
            grade = int(input("该职位最高级别为10，请重新录入级别："))
   elif job == 'T':
         while not grade >= 1 or not grade <= 6:
            grade = int(input("该职位最高级别为6，请重新录入级别："))
   elif job == 'M':
         while not grade >= 1 or not grade <= 3:
            grade = int(input("该职位最高级别为6，请重新录入级别："))
   return grade

def worker(self):
   uid = self.uid
   name = input("姓名：")
   job = input("职位（E.普通员工；T.组长；M.经理）：")
   year = int(input("工龄："))
   grade = self.ingrade(job)
   salary = self.salary(job, grade, year)
   if job == 'E':
         self.employee = Attribution(uid, name, job, grade, year, salary)
         print(f"录入成功！姓名：{self.employee.get_name}, 工号：{self.employee.get_uid}，薪资：{self.employee.salary}")
   elif job == 'T':
         self.teamleader = Attribution(uid, name, job, grade, year, salary)
         print(f"录入成功！姓名：{self.teamleader.get_name}, 工号：{self.teamleader.get_uid}，薪资：{self.teamleader.salary}")
   elif job == 'M':
         self.manager = Attribution(uid, name, job, grade, year, salary)
         print(f"录入成功！姓名：{self.manager.get_name}, 工号：{self.manager.get_uid}，薪资：{self.manager.salary}")
   self.uid += 1

def namefind(self):
   uid = int(input("请输入工号："))
   if uid in self.employee:
         print(f"姓名:{self.employee.get_name}\n职位：{self.employee.get_job}\n级别：{self.employee.get_grade}\n工龄：{self.employee.get_year}\n薪资：{self.employee.salary}")
   elif uid in self.teamleader:
         print(f"姓名:{self.teamleader.get_name}\n职位：{self.teamleader.get_job}\n级别：{self.teamleader.get_grade}\n工龄：{self.teamleader.get_year}\n薪资：{self.teamleader.salary}")
   elif uid in self.manager:
         print(f"姓名:{self.manager.get_name}\n职位：{self.manager.get_job}\n级别：{self.manager.get_grade}\n工龄：{self.manager.get_year}\n薪资：{self.manager.salary}")
   else:
         print("该工号不存在！")

def jobfind(self):
   job = input("职位（E.普通员工；T.组长；M.经理）：")
   if job == 'E':
         if len(self.employee) == 0:
            print("目前公司没有普通员工！")
         else:
            print(f"目前普通员工共有{len(self.employee)}人：")
            for i in self.employee:
               print(self.employee.get_uid, '-', self.employee.get_name)
   elif job == 'T':
         if len(self.teamleader) == 0:
            print("目前公司没有组长！")
         else:
            print(f"目前组长共有{len(self.teamleader)}人：")
            for i in self.teamleader:
               print(self.employee.get_uid, '-', self.employee.get_name)
   elif job == 'M':
         if len(self.manager) == 0:
            print("目前公司没有经理！")
         else:
            print(f"目前经理共有{len(self.manager)}人：")
            for i in self.manager:
               print(self.employee.get_uid, '-', self.employee.get_name)

def upgrade(self):
   uid = int(input("请输入工号："))
   if uid in self.employee:
         print(f"{self.employee.get_name}，工号：{self.employee.get_uid}，当前职位：E{self.employee.get_grade}，当前薪资：{self.employee.salary}")
         old_salary = self.employee.salary
         result = self.grade_change(self.employee.get_grade, self.employee.get_job)
         self.employee.get_grade = result
         self.employee.salary = self.salary(result, result, self.employee.get_year)
         change = self.employee.salary - old_salary
         if change > 0:
            tick = '+'
         else:
            tick = ''
         print("升级成功！")
         if result == 'E':
            print(f"{self.employee.get_name}，工号：{self.employee.get_uid}，当前职位：E{self.employee.get_grade}，升级后薪资：{self.employee.salary}({tick}{change})")
         elif result == 'T':
            self.employee.get_job = result
            print(f"{self.employee.get_name}，工号：{self.employee.get_uid}，当前职位：T{self.employee.get_grade}，升级后薪资：{self.employee.salary}({tick}{change})")
            self.teamleader = self.employee
            self.employee.pop(uid)
         elif result == 'M':
            self.employee.get_job = result
            print(f"{self.employee.get_name}，工号：{self.employee.get_uid}，当前职位：M{self.employee.get_grade}，升级后薪资：{self.employee.salary}({tick}{change})")
            self.manager = self.employee
            self.employee.pop(uid)

   elif uid in self.teamleader:
         print(f"{self.teamleader.get_name}，工号：{self.teamleader.get_uid}，当前职位：T{self.teamleader.get_grade}，当前薪资：{self.teamleader.salary}")
         old_salary = self.teamleader.salary
         result = self.grade_change(self.teamleader.get_grade, self.teamleader.get_job)
         self.teamleader.get_grade = result
         self.teamleader.salary = self.salary(result, result, self.teamleader.get_year)
         change = self.teamleader.salary - old_salary
         if change > 0:
            tick = '+'
         else:
            tick = ''
         print("升级成功！")
         if result == 'T':
            print(f"{self.teamleader.get_name}，工号：{self.teamleader.get_uid}，当前职位：T{self.teamleader.get_grade}，升级后薪资：{self.teamleader.salary}({tick}{change})")
         elif result == 'M':
            self.teamleader.get_job = result
            print(f"{self.teamleader.get_name}，工号：{self.teamleader.get_uid}，当前职位：M{self.teamleader.get_grade}，升级后薪资：{self.teamleader.salary}({tick}{change})")
            self.manager = self.teamleader
            self.teamleader.pop(uid)

   elif uid in self.manager:
         print(f"{self.manager.get_name}，工号：{self.manager.get_uid}，当前职位：M{self.manager.get_grade}，当前薪资：{self.manager.salary}")
         old_salary = self.manager.salary
         result = self.grade_change(self.manager.get_grade, self.manager.get_job)
         self.manager.get_grade = result
         self.manager.salary = self.salary(result, result, self.teamleader.get_year)
         change = self.manager.salary - old_salary
         if change > 0:
            tick = '+'
         else:
            tick = ''
         print("升级成功！")
         print(f"{self.manager.get_name}，工号：{self.manager.get_uid}，当前职位：M{self.manager.get_grade}，升级后薪资：{self.manager.salary}({tick}{change})")
   else:
         print("该工号不存在！")

def grade_change(self, grade, job):
   result = []
   add = int(input("请输入需要增加的级数："))
   num = grade + add
   if job == 'E':
         if num <= 10:
            result.append(num)
            result.append('E')
         elif 10 < num <= 16:
            result.append(num - 10)
            result.append('T')
         elif 16 < num <= 19:
            result.append(num - 16)
            result.append('M')
         else:
            print("超过最高级别，无效！")
            return
   elif job == 'T':
         if num <= 6:
            result.append(num)
            result.append('T')
         elif 6 < num <= 9:
            result.append(num - 6)
            result.append('M')
         else:
            print("超过最高级别，无效！")
            return
   elif job == 'M':
         if num <= 3:
            result.append(num)
            result.append('M')
         else:
            print("超过最高级别，无效！")
            return
   return result

def main():
a = Manage()
num = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
while num != 5:
   if num == 1:
         a.worker()
   elif num == 2:
         choice = int(input("1.员工查询；2.职位查询："))
         if choice == 1:
            a.namefind()
         elif choice == 2:
            a.jobfind()
   elif num == 3:
         a.upgrade()
   elif num == 4:
         pass
   else:
         print("指令错误，请重新输入：")
   num = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))


main()

nicezzz 发表于 2025-1-28 02:45:28

ilaf 发表于 2025-1-26 21:53:48

检测点11.1 发表于 2025-1-24 10:33:56

one functin/method/attribute/operator can deal with different situation.

increase cohesion, decrease coupling.

yes, it's polymorphism.

when a thin looks like duck, bark like a duck, and walk like a duck, then it is a duck.

decrease coupling, because it deal with defferent object with uniform style.

yes, it s.

yes, it is.

保尔·柯察恒 发表于 2025-1-22 02:46:10

请回复您的答案^_^

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

第 0 题的答案是：
同一个方法、运算符等因为被操作的对象不同而采取不同的处理方法、得到不一样的结果，叫做多态
第 1 题的答案是：
s使得代码更灵活
第 2 题的答案是：
可以
第 3 题的答案是：
不知道
第 4 题的答案是：
低耦合
第 5 题的答案是：
是
-------- 动动手 --------

请将第 0 题的代码写在下方：
class Employee:
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 salary(self):
   return 3000 + 500 * self.grade + 50 * self.year

class Teamleader(Employee):
def __init__(self, empl):
   super().__init__(empl.uid, empl.name, 'T', empl.grade, empl.year)

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

class Manager(Employee):

def __init__(self, empl):
   super().__init__(empl.uid, empl.name, 'M', empl.grade, empl.year)

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

class Main:

def __init__(self):
   self.employees = []
   self.uid = 10000
   self.max_grage = {'E': 10, 'T': 6, 'M': 3}
   self.job_name = {'E': '普通员工', 'T': '组长', 'M': '经理'}

def get_empl(self, uid):
   for e in self.employees:
         if uid == e.uid:
            return e
   else:
         return None

def add(self):
   uid = self.uid
   name = input("姓名：")
   job = input("职位（E.普通员工；T.组长；M.经理）：")
   year = int(input("工龄："))
   grade = int(input("级别："))
   while grade > self.max_grage:
         grade = int(input(f"该级别最高为{self.max_grage}，请重新输入："))

   empl = Employee(uid, name, job, grade, year)
   if job == 'T':
         empl = Teamleader(empl)
   elif job == 'M':
         empl = Manager(empl)

   self.employees.append(empl)
   print(f"录入成功，姓名：{name}，工号：{uid}，薪资：{empl.salary()}")
   self.uid += 1

def empl_query(self):
   empl = self.get_empl(int(input("请输入工号：")))
   if not empl:
         print("该工号不存在 ")
         return
   print(f"姓名：{empl.name}")
   print(f"职位：{empl.job}")
   print(f"级别：{empl.grade}")
   print(f"工龄：{empl.year}")
   print(f"薪资：{empl.salary()}")

def job_query(self):
   jobs = []
   cnt = 0
   job = input("职位（E.普通员工；T.组长；M.经理）：")
   for e in self.employees:
         if job == e.job:
            jobs.append(e)
            cnt += 1
   if cnt == 0:
         print(f"目前公司没有{self.job_name}")
   else:
         print(f"目前{self.job_name}共有{cnt}人")
         for e in jobs:
            print(f"{e.uid} - {e.name}")

def query(self):
   op = input("1.员工查询；2.职位查询")
   if op == '1':
         self.empl_query()
   elif op == '2':
         self.job_query()

def upgrade(self):
   empl = self.get_empl(int(input("请输入工号：")))
   if not empl:
         print("该工号不存在 ")
         return
   print(f"{empl.name}，工号：{empl.uid}，当前职位：{empl.job + str(empl.grade)}，当前薪资：{empl.salary()}")
   num = int(input("请输入需要增加的级数："))
   empl.grade += num
   if empl.grade > self.max_grage:
         self.employees.remove(empl)
         if empl.job == 'E':
            empl.grade = 1
            empl = Teamleader(empl)
         elif empl.job == 'T':
            empl.grade = 1
            empl = Manager(empl)
         elif empl.job == 'M':
            empl.grade = 3
            print("已经是最高级！")
         self.employees.append(empl)
   print(f"{empl.name}，工号：{empl.uid}，升级后职位：{empl.job + str(empl.grade)}，升级后薪资：{empl.salary()}")

def downgrade(self):
   empl = self.get_empl(int(input("请输入工号：")))
   if not empl:
         print("该工号不存在 ")
         return
   print(f"{empl.name}，工号：{empl.uid}，当前职位：{empl.job + str(empl.grade)}，当前薪资：{empl.salary()}")
   num = int(input("请输入需要降低的级数："))
   empl.grade -= num
   if empl.grade < 1:
         self.employees.remove(empl)
         if empl.job == 'E':
            empl.grade = 1
            print("已经是最低级！")
         elif empl.job == 'T':
            empl = Employee(empl.uid, empl.name, 'E', 10, empl.year)
         elif empl.job == 'M':
            empl.grade = 6
            empl = Teamleader(empl)
         self.employees.append(empl)
   print(f"{empl.name}，工号：{empl.uid}，升级后职位：{empl.job + str(empl.grade)}，升级后薪资：{empl.salary()}")

def welcome(self):
   while True:
         op = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
         if op == '1':
            self.add()
         elif op == '2':
            self.query()
         elif op == '3':
            self.upgrade()
         elif op == '4':
            self.downgrade()
         elif op == '5':
            break

def main():
Main().welcome()

main()

zyx2012 发表于 2025-1-19 20:33:32

页: 5 6 7 8 9 10 11 12 13 14 [15] 16 17 18 19 20 21 22 23 24

鱼C论坛's Archiver