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

Superfreak 发表于 2024-8-27 17:59:38

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

Walson777 发表于 2024-8-26 14:19:08

凯文1 发表于 2024-8-25 19:06:06

请回复您的答案^_^

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

第 0 题的答案是：不同类的对象对同一消息做出响应

第 1 题的答案是：代码重用和扩展性，简化接口

第 2 题的答案是：算

第 3 题的答案是：如果它走起来像鸭子，叫声像鸭子，那它很可能就是一只鸭子。

第 4 题的答案是：内聚

第 5 题的答案是：不算

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

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

自行车vcd 发表于 2024-8-25 12:03:53

请回复您的答案^_^

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

第 0 题的答案是：
通过类写出特性，在函数里统一调用

第 1 题的答案是：
便于调用

第 2 题的答案是：
可以

第 3 题的答案是：
如果它走起来像鸭子，叫起来也像鸭子，那么它就是鸭子

第 4 题的答案是：
降低了耦合度

第 5 题的答案是：
属于

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

请将第 0 题的代码写在下方：
class Members:
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):
   self.uid+=1
   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,job):
   if job=='E':
         return 3000+500*self.grade+50*self.year
   if ob=='T':
         return 4000+800*self.grade+100*self.year
   if job=='M':
         return 5000+1000*(self.grade+self.year)

class GradeMixin:
#进行级别检测
def is_tooheigh(self,grade,job):
   if job=='E':
         while grade>10:
            grade=int(input('该职位最高级别为10，请重新录入级别：'))
   if job=='T':
         while grade>6:
            grade=int(input('该职位最高级别为6，请重新录入级别：'))
   if job=='M':
         while grade>3:
            grade=int(input('该职位最高级别为3，请重新录入级别：'))
   return grade


class Manage(GradeMixin):
def __init__(self):
   self.members={}
   self.uid=10000

def welcome(self):
   ins=0
   while ins!='5':
         ins=input('1.录入;2.查询;3.升级;4.降级;5.退出：')
         if ins=='1':
            pass
         if ins=='2':
            pass
         if ins=='3':
            pass
         if ins=='4':
            pass

def confirm_passwd(self):
   uid=int(input('请输入工号：'))
   if self.members.get(uid)==None:
         print('该工号不存在!')
   return uid

def create_member(self):
   name=input('姓名：')
   job=input('职位（E.普通员工;T.组长;M.经理;）：')
   year=int(input('工龄：'))
   grade=int(input('级别:'))
   grade=self.is_tooheigh(grade,job)
   member=Member(name,job,grade,year,self.uid)
   self.members=member
   print(f"录入成功！姓名：{name},工号：{self.uid}，薪资：{Member().salary(job)}")
   self.uid+=1

def member_chaxun(self):
   a=input('1.员工查询;2.职位查询：')
   if a=='1':
         uid=self.confim_passwd()
         print(f"姓名：{self.members.name}\n职位：{self.members.job}\n级别：{self.members.grade}\n工龄：{self.members.year}\n薪资：{Member().salary(self.members.job)}")
   if a=='2':
         job=input('职位（E.普通员工;T.组长;M.经理;）：')
         if job=='E':

            print(f"")
         if job=='T':

         if job=='M':

2666 发表于 2024-8-23 14:26:13

请回复您的答案^_^

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

第 0 题的答案是：0

第 1 题的答案是：1

第 2 题的答案是：2

第 3 题的答案是：3

第 4 题的答案是：4

第 5 题的答案是：5

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

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

Alexa_ 发表于 2024-8-21 00:09:28

请回复您的答案^_^

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

第 0 题的答案是：

Python是一门动态语言。在类和对象中，Python可以通过子类对父类方法的重写来体现多态特性

第 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 Stuff:

def __init__(self):
   self.stuff = {}
   self.next_uid = 10000

# 选择功能
def welcome(self):
   while True:
         order = int(input("\n1.录入；2.查询；3.升级；4.降级；5.退出："))

         if order == 1:
            self.record()
         if order == 2:
            self.query()
         if order == 3:
            self.level_change(3)
         if order == 4:
            self.level_change(4)
         if order == 5:
            break

# 员工方法
def get_uid(self):
   uid = self.next_uid
   self.next_uid += 1
   return uid
def get_name(self):
   name = input("姓名：")
   return name
def get_job(self):
   job = input("职位（E.普通员工；T.组长；M.经理）：")
   return job
def get_year(self):
   year = int(input("工龄："))
   return year
def get_grade(self):
   grade = int(input("级别："))
   return grade
def salary(self):
   pass

# 级别检查
def grade_check(self, grade, job):
   if job == 'E':
         while grade > 10:
            grade = int(input("该职位最高级别为10，请重新输入级别："))
   elif job == 'T':
         while grade > 6:
            grade = int(input("该职位最高级别为6，请重新输入级别："))
   elif job == 'M':
         while grade > 3:
            grade = int(input("该职位最高级别为3，请重新输入级别："))
   return grade

# 录入
def record(self):

   uid = self.get_uid()
   name = self.get_name()
   job = self.get_job()
   year = self.get_year()
   grade = self.get_grade()
   grade = self.grade_check(grade, job)

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

   stuff.salary = stuff.get_salary(grade, year)

   self.stuff = stuff
   print(f'录入成功！姓名：{stuff.name}，工号：{stuff.uid}，薪资：{stuff.salary}')

# 查询
def query(self):

   func = int(input("1.员工查询；2.职位查询："))

   if func == 1:
         uid_to_check = int(input("请输入工号："))
         if uid_to_check not in self.stuff:
            print("该工号不存在！")
         else:
            stuff = self.stuff
            print(f'姓名：{stuff.name}\n职位：{stuff.job}\n级别：{stuff.grade}\n工龄：{stuff.year}\n薪资：{stuff.salary}')

   if func == 2:
         job_to_check = input("职位（E.普通员工；T.组长；M.经理）：")
         job_list = {"E":"普通员工", "T":"组长", "M":"经理"}
         num = 0
         l = []
         for uid, stuff in self.stuff.items():
            if stuff.job == job_to_check:
               num += 1
               l.append(stuff)
         if num != 0:
            print(f"目前{job_list}共有 {num} 人；")
            for stuff in l:
               print(f"{stuff.uid} - {stuff.name}")
         else:
            print(f"目前公司没有{job_list}！")

# 级别改变功能实现
def level_change(self,order=None):

   uid_to_change = int(input("请输入工号："))
   stuff = self.stuff
   print(f'{stuff.name}，工号：{stuff.uid}，当前职位：{stuff.job+str(stuff.grade)}，当前薪资：{stuff.salary}')

   old_salary = stuff.salary

   if order == 3:
         level_to_change = "+" + input("请输入需要增加的级数：")
   elif order == 4:
         level_to_change = "-" + input("请输入需要减少的级数：")

   level_now, job_now = stuff.job_change(eval(level_to_change))

   if job_now == "E":
         stuff = Employee(stuff.uid, stuff.name, job_now, stuff.year,level_now) # 这里没有创建salary属性，也就是说salary现在不可调用
         self.stuff = stuff
   elif job_now == "T":
         stuff = Teamleader(stuff.uid, stuff.name, job_now, stuff.year,level_now)
         self.stuff = stuff
   elif job_now == "M":
         stuff = Manager(stuff.uid, stuff.name, job_now, stuff.year, level_now)
         self.stuff = stuff

   stuff.salary = stuff.get_salary(stuff.grade, stuff.year)
   salary_change = stuff.salary - old_salary

   if order == 3:
         print("升级成功！")
         print(f"{stuff.name}，工号：{stuff.uid}，升级后职位：{stuff.job+str(stuff.grade)}，升级后薪资：{stuff.salary}（{'{:+}'.format(salary_change)}）")
   elif order == 4:
         print("降级成功！")
         print(f"{stuff.name}，工号：{stuff.uid}，降级后职位：{stuff.job+str(stuff.grade)}，降级后薪资：{stuff.salary}（{'{:+}'.format(salary_change)}）")

class Employee(Stuff):

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

def get_salary(self, grade, year):
   self.salary = 3000 + 500 * grade + 50 * year
   return self.salary

def job_change(self, level_to_change):

   total = self.grade + level_to_change

   if total <= 10:
         level_now = total
         job_now = "E"
   if total > 10 and total <= 16:
         level_now = 1
         job_now = "T"
   if total > 16 and total <= 19:
         level_now = 1
         job_now = "M"

   return level_now, job_now

class Teamleader(Stuff):

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

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

def job_change(self, level_to_change):

   total = 10 + self.grade + level_to_change

   if total <= 10:
         level_now = 10
         job_now = "E"
   if total > 10 and total <= 16:
         level_now = total - 10
         job_now = "T"
   if total > 16 and total <= 19:
         level_now = 1
         job_now = "M"

   return level_now, job_now

class Manager(Stuff):

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

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

def job_change(self, level_to_change):

   total = 16 + self.grade + level_to_change

   if total <= 10:
         level_now = 10
         job_now = "E"
   if total > 10 and total <= 16:
         level_now = 6
         job_now = "T"
   if total > 16 and total <= 19:
         level_now = total - 16
         job_now = "M"

   return level_now, job_now

def main():
s = Stuff()
s.welcome()

main()

18874875949 发表于 2024-8-19 14:14:57

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：
多态的优势，一个模板，只要符合要求就能套壳使用
第 2 题的答案是：
可以称为多态
第 3 题的答案是：
不知道
第 4 题的答案是：
增强了内聚
第 5 题的答案是
是的
-------- 动动手 --------

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

miyum 发表于 2024-8-17 16:06:33

请回复您的答案^_^
0，子类可以继承父类方法并重写

1，不同类型的对象，调用同一个方法得到不同的结果

2，是

3，

4，增强内聚

5，不算

class Employee:
edict = {}
elist = []
def __init__(self,name,job,grade,year):
   self.name = name
   self.job = job
   self.grade = grade
   self.year = year
   self.uid = len(self.elist)+10000
   self.total = 0

def salary_employee(self,job,grade):
   if job == 'E':
         self.total = 3000+500*int(grade)+50*int(year)
   elif self.job == 'T':
         self.total = 4000+800*int(grade)+100*int(year)
   elif self.job == 'M':
         self.total = 5000+1000*(int(grade)+int(year))
   else:
         print("输入有误~")
   return self.total

def add_employee(self):
   self.salary_employee(self.job,self.grade)
   self.edict = {"姓名":self.name,"职位":self.job,"级别":self.grade,"工龄":self.year,"薪资":self.total}
   self.elist.append(self.edict)
   print(f'录入成功！姓名：{self.name},工号：{self.uid},薪资：{self.total}')

def get_name(self,uid):
   return self.edict["姓名"]

def get_job(self,uid):
   return self.edict["职位"]

def get_grade(self,uid):
   return self.edict["级别"]

def get_year(self,uid):
   return self.edict["工龄"]

def get_salary(self,uid):
   return self.edict["薪资"]

def count_job(self,job):
   count = 0
   select_dict = {}
   for key,value in self.edict.items():
         if value["职位"] == job:
            count +=1
            select_dict = value['姓名']
         match job:
            case 'E':
               print(f"目前普通员工共有{count}人：")
            case 'T':
               print(f"目前组长共有{count}人:")
            case 'M':
               print(f"目前经理共有{count}人:")

         for key,value in select_dict.items():
            print(f"{key} - {value}")

class LevelMixin(Employee):
def check_level(self,job,grade,temp_level):

   while True:
         if job == 'E' and grade+temp_level >10:
            temp_level = int(input("该职位最高级为10，请输入新的级别："))
         elif job == 'T' and grade+temp_level > 6:
            temp_level = int(input("该职位最高级为6，请输入新的级别："))
         elif job == 'M' and grade+temp_level >3:
            temp_level = int(input("该职位最高级为3，请输入新的级别："))
         elif job == 'E' and 0:
            return grade+temp_level
def lower_level(self,uid):
      temp_level = int(input("请输入需要减少的级数："))
      new_level = self.check_level(job,grade,0-temp_level)
      new_salary = self.salary_employee(self.get_job(uid),new_level)
      print("降级成功！")
      print(f"{emp.get_name(uid)}，工号：{uid}，降级后的职位：{emp.get_job(uid)}{new_level}，升级后薪资：{new_salary}（-{emp.get_salary(uid)-new_salary}）")
      self.edict["薪资"] = new_salary
      self.edict["级别"] = new_level

def add_level(self,job,grade):
      temp_level = int(input("请输入需要增加的级数："))
      new_level = self.check_level(job,grade,temp_level)
      new_salary = self.salary_employee(self.get_job(uid),new_level)
      print("升级成功！")
      print(f"{emp.get_name(uid)}，工号：{uid}，升级后的职位：{emp.get_job(uid)}{new_level}，升级后薪资：{new_salary}（+{new_salary-emp.get_salary(uid)}）")
      self.edict["薪资"] = new_salary
      self.edict["级别"] = new_level

if __name__ == '__main__':
   while True:
         temp = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
         match temp:
            case '1':
               name = input("姓名：")
               job = input("职位：")
               grade = int(input("级别："))
               l = LevelMixin(1,1,1,1)
               grade = l.check_level(job,grade,0)
               year = int(input("工龄："))
               emp = Employee(name,job,grade,year)
               emp.add_employee()
               continue
            case '2':
               emp = Employee(1,1,1,1)
               temp = input("1.员工查询；2.职位查询：")
               match temp:
                     case '1':
                        temp_uid = int(input("请输入工号："))

                        if temp_uid in emp.edict.keys():
                           print(f"姓名：{emp.get_name(temp_uid)}\n职位：{emp.get_job(temp_uid)}\n级别：{emp.get_grade(temp_uid)}\n工龄：{emp.get_year(temp_uid)}\n薪资：{emp.get_salary(temp_uid)}")
                           continue
                        else:
                           print("该工号不存在！！")
                        continue
                     case '2':
                        job = input("请输入职位(E.普通员工；T.组长；M.经理)：")

                        count_job = emp.count_job(job)
                        continue
                     case _:
                           print("输入有误！！！")
               continue
            case '3':
               lm = LevelMixin(1,1,1,1)
               emp = Employee(1,1,1,1)
               uid = int(input("请输入工号："))
               print(f"{emp.get_name(uid)}，工号：{uid}，当前职位：{emp.get_job(uid)}{emp.get_grade(uid)}，当前薪资：{emp.get_salary(uid)}")
               lm.add_level(emp.get_job(uid),emp.get_grade(uid))
               continue

            case '4':
               uid = int(input("请输入工号："))
               continue
               pass
            case '5':
               break
            case _:
               print("输入有误！！！")
               break

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

wshxyl001 发表于 2024-8-16 09:21:12

请回复您的答案^_^

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

第 0 题的答案是：通过传入不同参数, 呈现不同的结果

第 1 题的答案是：代码的重复, 易于维护, 接口统一

第 2 题的答案是：可以

第 3 题的答案是：

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

第 5 题的答案是：不属于多态

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

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

cleo8023 发表于 2024-8-15 08:11:40

64991109 发表于 2024-8-14 14:34:47

各位大佬这么写有没有问题，运行起来是正常的
class attribute:
def __init__(self ,name ,job ,grade ,year ,uid):
   self.name = name
   self.job = job
   self.grade = grade
   self.year = year
   self.uid = uid
def get_uid(self):
   return self.uid
def get_name(self):
   return self.name
def get_job(self):
   return self.job
def get_grade(self):
   return self.grade
def get_year(self):
   return self.year
def salary(self):
   if self.job == 'E':
         return 3000 + 500 * int(self.grade) + 50 * int(self.year)
   elif self.job == 'T':
         return 4000 + 800 * int(self.grade) + 100 * int(self.year)
   elif self.job == 'M':
         return 5000 + 1000 * (int(self.grade) + int(self.year))

class StaffMixin:
def classification(self):
   post = input('职位(E.普通员工 T.组长 M.经理)')
   while post != 'E' and post != 'T' and post != 'M':
         post = input('输入错误，请输入职位代号（大写），E.普通员工 T.组长 M.经理')
   return post

def up_rank(self,post,num):
   post = post + str(int(post)+int(num))
   if post == 'E' and int(post) > 10:
         return 'T1'
   elif post == 'T' and int(post) > 6:
         return 'M1'
   elif post == 'M' and int(post) > 3:
         return 'M3'
   else:
         return post
def down_rank(self,post,num):
   post = post + str(int(post)-int(num))
   if post == 'E' and int(post) < 1:
         return 'E1'
   elif post == 'T' and int(post) < 1:
         return 'E10'
   elif post == 'M' and int(post) < 1:
         return 'T6'
   return post

class staff(StaffMixin):
def __init__(self):
   self.staffs = {}
   self.uid = 10000

def welcome(self):
   tag = ''
   while tag != '5':
         tag = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
         if tag == '1':
            self.enter()
         elif tag == '2':
            self.inquire()
         elif tag == '3':
            self.up_grade()
         elif tag == '4':
            self.down_grade()

def grade_dec(self,job):
   grade = input('级别:')
   while 1:
         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，请重新输入：')
         else:
            return grade
def enter(self):
   name = input("姓名：")
   job = self.classification()
   year = input('工龄:')
   grade = self.grade_dec(job)
   temp = attribute(name, job, grade, year, self.uid)
   self.staffs = temp
   print(f'录入成功!姓名:{self.staffs.name},工号：{self.uid},薪资:{self.staffs.salary()}')
   self.uid += 1
def inquire(self):
   tag = input('1.员工查询，2.职位查询：')
   if tag == '1':
         uid = int(input('请输入工号：'))
         if not (uid in self.staffs):
            print('该工号不存在')
            return 0
         print(f'姓名：{self.staffs.get_name()}')
         print(f'职位：{self.staffs.get_job()}')
         print(f'级别：{self.staffs.get_grade()}')
         print(f'工龄：{self.staffs.get_year()}')
         print(f'工资：{self.staffs.salary()}')
   elif tag == '2':
         job = input('职位（E.普通员工,T.组长,M经理）:')
         temp = 0
         for i in self.staffs.values():
            if i.get_job() == job:
               print(f"{i.get_uid()}-{i.get_name()}")
               temp = 1
         if temp == 0:
            if job == 'E':
               print('目前没有普通员工！')
            elif job == 'T':
               print('目前没有组长！')
            elif job == 'M':
               print('目前没有经理！')
def up_grade(self):
   uid = int(input('请输入工号：'))
   if not (uid in self.staffs):
         print('该工号不存在')
         return 0
   up_num = input('请输入需要增加的级数：')
   old_salary = self.staffs.salary()
   temp = self.up_rank(self.staffs.get_job()+self.staffs.get_grade(),up_num)
   self.staffs.job = temp
   self.staffs.grade = temp
   print('升级成功')
   print(f'{self.staffs.get_name()}，工号{self.staffs.get_uid()}，升级后职位{temp},升级后薪资：{self.staffs.salary()}({self.staffs.salary() - old_salary})')
def down_grade(self):
   uid = int(input('请输入工号：'))
   if not (uid in self.staffs):
         print('该工号不存在')
         return 0
   down_num = input('请输入需要减少的级数：')
   old_salary = self.staffs.salary()
   temp = self.down_rank(self.staffs.get_job()+self.staffs.get_grade(),down_num)
   self.staffs.job = temp
   self.staffs.grade = temp
   print('降级成功')
   print(f'{self.staffs.get_name()}，工号{self.staffs.get_uid()}，降级后职位{temp},降级后薪资：{self.staffs.salary()}({self.staffs.salary() - old_salary})')
temp =staff()
temp.welcome()

Abnormalvis 发表于 2024-8-13 22:30:36

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

请将第 0 题的代码写在下方：
import time
#记录员工的关键信息
class staff:
def __init__(self,uid,name,year,grade,job):
   self.uid = uid
   self.name = name
   self.year = year
   self.grade = grade
   self.job = job

class LoggerMixin:
def log(self,message,filename='log（1）.txt'）:
         with open(filename,'a') as f:
         f.write(message)

class Manage(LoggerMixin):
def __init__(self):
   self.staffs = {}
   self.uid = 10000

def welcome(self):
   ins = 0
   print('欢迎使用公司员工查询系统！')
   while ins!=5:
         ins = ('\n1、录入；2、查询；3、升级；4、降级；5、退出：')
         if ins == '1':
            self.log_in_staff()
         if ins == '2':
            self.look_up_staff()
         if ins == '3':
            self.upgrade_staff()
         if ins == '4':
            self.downgrade_staff()
         if ins == '5':
            print('退出系统！')

def confirm_uid(self):
   uid = int(input('请输入工号：'))
   while not self,uid,get(uid):
         uid = int(input('该卡号不存在，请重新输入:'))
   return uid
def log_in_staff(self):
   name = input('请输入员工姓名：')
   A = input('职位（E.普通员工；T.组长；M.经理）')
   if A == 'E':
         job = '普通员工'
   elif A == 'T':
         job = '组长'
   elif A == 'M':
         job = '经理'
   year = int(input('请输入工龄：'))
   grade = int(input('请输入级别'))
   regdate = time.localtime()
   staff = staff(self.uid,name,year,grade,job,regdate)
   self.staff = staff
   print(f'员工信息录入成功：{self.uid}->{name},时间是:{time.strftime('%Y-%m-%d %H:%M:%S', regdate)}\n")
   self.uid += 1

def look_up_staff(self):
   def get_uid(self):
         print(self.uid)
   def get_name(self):
         print(self.name)
   def get_job(self):
         print(self.job)
   def get_year(self):
         print(self.year)
   def get_grade(self):
         print(self.grade)
   def get_salary(self):
         if self.job == '普通员工':
            salary = 3000 + 500 * self.grade + self.year * 50
         if self.job == '组长':
            salary = 4000 + 800 * self.grade + self.year * 100
         if self.job = '经理':
            salary = 5000 + 1000 * (self.grade + self.year)
         return salary

def upgrade_staff(self):
   num_upgraded = int(input('请输入升级的级数:'))
   if self.job = '普通员工':
         while num_upgraded + self.grade > 10:
            num_upgraded = input('非法录入，请重新输入：')
   if self.job = '组长':
         while num_upgraded + self.grade > 6:
            num_upgraded = input('非法录入，请重新输入：')
   if self.job = '经理':
         while num_upgraded + self.grade > 3:
            num_upgraded = input('非法录入，请重新输入：')

def downgrade_staff(self):
   if self.job = '普通员工':
         while num_upgraded + self.grade < 1:
            num_upgraded = input('非法录入，请重新输入：')
   if self.job = '组长':
         while num_upgraded + self.grade < 1:
            num_upgraded = input('非法录入，请重新输入：')
   if self.job = '经理':
         while num_upgraded + self.grade < 1:
            num_upgraded = input('非法录入，请重新输入：')

def main():
s = staff()
s.welcome()

Abnormalvis 发表于 2024-8-13 19:56:39

请回复您的答案^_^

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

第 0 题的答案是：向同一个函数，传递不同参数后，可以实现不同功能.

第 1 题的答案是：
可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强；多态是调用方法的技巧，不会影响到类的内部设计。
第 2 题的答案是：可以

第 3 题的答案是：

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

第 5 题的答案是：不是

zacefron 发表于 2024-8-13 14:36:22

64991109 发表于 2024-8-13 09:56:56

HT420 发表于 2024-8-11 12:22:03

请回复您的答案^_^

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

第 0 题的答案是：
不同对象对应的特性不同
第 1 题的答案是：
可以单独处理各自的内容
第 2 题的答案是：
可以
第 3 题的答案是：
不会
第 4 题的答案是：
高内聚
第 5 题的答案是：
不属于
-------- 动动手 --------

请将第 0 题的代码写在下方：
"""企业员工管理"""

class Employ:
Employees = []
Teamleaders = []
Managers = []

def __init__(self,name,job):
   if job == "普通员工":
         self.Employees.append(name)
   elif job == "组长":
         self.Teamleaders.append(name)
   elif job == "经理":
         self.Managers.append(name)

def dispaly(self):
   print(f"普通员工：{self.Employees}")
   print(f"组长：{self.Teamleaders}")
   print(f"经理：{self.Managers}")

class jobs():

sums = []
yuangong = []
dollers = []

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

   self.yuangong =
   self.sums.append(self.yuangong)

def salary(self):

   if self.yuangong == "普通员工":
         doller = 3000 + 500 * int(self.yuangong) + 50 * int(self.yuangong)

   elif self.yuangong == "组长":
         doller = 4000 + 800 * int(self.yuangong) + 100 * int(self.yuangong)

   else:
         doller = 5000 + 1000 * int(self.yuangong) + 1000 * int(self.yuangong)

   self.dollers.append(doller)
   return doller

def main():

uid = 10000

while True:
   choose = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))

   if choose == 1:
         name = input("姓名：")
         job1 = input("职位（E.普通员工；T.组长；M.经理）：")
         if job1 == 'E':
            job = "普通员工"
         elif job1 == 'T':
            job = "组长"
         elif job1 == 'M':
            job = "经理"
         year = int(input("工龄："))
         grade = int(input("级别："))

         e = Employ(name,job)
         js = jobs(name,job,grade,year,uid)
         s = js.salary()

         print(f"录入成功！姓名：{name}，工号：{uid}，薪资：{s}")
         uid = uid + 1

   if choose == 2:
         choose2 = int(input("1.员工查询；2.职位查询："))
         if choose2 == 1:
            n = -1
            uids = int(input("请输入工号:"))

            if uids <= uid:
               for i in js.sums:
                     n = n + 1
                     if uids == int(i):
                        print(f"姓名：{i}")
                        print(f"职位：{i}")
                        print(f"级别：{i}")
                        print(f"工龄：{i}")
                        print(f"薪资：{js.dollers}")
                        break
            else:
               print("该工号不存在！")

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

            if jobss == 'E':
               E = e.Employees
               print(f"普通员工共有{len(E)}人；")
               if len(E) > 0:
                     for i in E:
                        print(f"{i}")

            elif jobss == 'T':
               T = e.Teamleaders
               print(f"组长共有{len(T)}人；")
               if len(T) > 0:
                     for i in T:
                        print(f"{i}")

            elif jobss == 'M':
               M = e.Managers
               print(f"经理共有{len(M)}人；")
               if len(M) > 0:
                     for i in M:
                        print(f"{i}")

   if choose == 3:

   if choose == 5:
         break

main()

Naud_Seong 发表于 2024-8-11 10:17:22

huimie17 发表于 2024-8-7 16:41:58

jingtiandi123 发表于 2024-8-7 16:21:08

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

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

第 4 题的答案是：

第 5 题的答案是：
嗯
-------- 动动手 --------

请将第 0 题的代码写在下方：
class Method:
def employee(self,grade,year):
   self.pay1 = 3000 + 500 * grade + 50* year
def teamleader(self,grade,year):
   self.pay2 = 4000 + 800 * grade + 100* year
def manager(self,grade,year):
   self.pay3 = 5000 + 1000 * (grade + year)
class Get:
count = 0
def get_uid(self):
   self.uid = 10000 + self.count
   self.count += 1
def get_name(self):
   self.name = input('姓名：')
def get_job(self):
   self.job = input('职位（E.普通员工；T.组长；M.经理）：')
def get_year(self):
   self.year = int(input('工龄：'))
def get_grade(self):
   self.grade = int(input('级别：'))
   if self.job == 'E':
         while self.grade < 0 or self.grade > 10:
            self.grade = int(input('该职位最低级别为1，最高级别为10，请重新录入级别：'))
   elif self.job == 'T':
         while self.grade < 0 or self.grade > 6:
            self.grade = int(input('该职位最低级别为1，最高级别为6，请重新录入级别：'))
   elif self.job == 'M':
         while self.grade < 0 or self.grade > 3:
            self.grade = int(input('该职位最低级别为1，最高级别为3，请重新录入级别：'))
def get_salary(self,pay):
   self.salary = pay
class Function(Get,Method):
player = {}

def enroll(self):
   super().get_name()
   super().get_job()
   super().get_year()
   super().get_grade()
   super().get_uid()
   if self.job == 'E':
         super().employee(self.grade,self.year)
         super().get_salary(self.pay1)
   elif self.job == 'T':
         super().teamleader(self.grade,self.year)
         super().get_salary(self.pay2)
   elif self.job == 'M':
         super().manager(self.grade,self.year)
         super().get_salary(self.pay3)
   self.player =
   print('录入成功！姓名：',self.name,'工号：',self.uid,'薪资：',self.salary)
def inquiry(self):
   self.choice = int(input('1.员工查询；2.职位查询：'))
   if self.choice == 1:
         self.inquiry_uid = int(input('请输入工号：'))
         if self.inquiry_uid in self.player:
            print('姓名：',self.player)
            print('职位：',self.player)
            print('级别：',self.player)
            print('工龄：',self.player)
            print('薪资：',self.player)
         else:
            print('该工号不存在！')
   elif self.choice == 2:
         self.k = 0
         self.ku = []
         self.inquiry_job = input('职位（E.普通员工；T.组长；M.经理）：')
         for i in self.player:
            if self.inquiry_job in self.player:
               self.ku.append(f'{i} - {self.player}')
               self.k += 1
         if self.inquiry_job == 'E':
            print('目前普通员工共有',self.k,'人')
         elif self.inquiry_job == 'T':
            print('目前组长共有',self.k,'人')
         elif self.inquiry_job == 'M':
            print('目前经理共有',self.k,'人')
         if self.k != 0:
            for z in self.ku:
               print(z)
         else:
            self.cun = {'E':'普通员工','T':'组长','M':'经理'}
            print('目前公司没有',self.cun,'!',sep = '')
def upgrade(self):
   self.upgrade_uid = int(input('请输入工号：'))
   if self.upgrade_uid in self.player:
         print(self.player,'工号：',self.upgrade_uid,'当前职位:',self.player+str(self.player),'当前薪资：',self.player)
         self.up_grade = int(input('请输入需要增加的级数：'))
         if self.player == 'E':
            if self.player + self.up_grade > 10:
               self.player = 'T'
               self.player = 1
               super().teamleader(1,self.player)
               self.price_difference = self.pay2 - self.player
               self.player = self.pay2
               print('升级成功！')
            else:
               self.player = self.player + self.up_grade
               super().employee(self.player,self.player)
               self.price_difference = self.pay1 - self.player
               self.player = self.pay1
               print('升级成功！')
         elif self.player == 'T':
            if self.player + self.up_grade > 6:
               self.player = 'M'
               self.player = 1
               super().manager(1,self.player)
               self.price_difference = self.pay3 - self.player
               self.player = self.pay3
               print('升级成功！')
            else:
               self.player = self.player + self.up_grade
               super().teamleader(self.player,self.player)
               self.price_difference = self.pay2 - self.player
               self.player = self.pay2
               print('升级成功！')
         elif self.player == 'M':
            if self.player + self.up_grade <= 3:
               self.player = self.player + self.up_grade
               super().manager(self.player,self.player)
               self.price_difference = self.pay3 - self.player
               self.player = self.pay3
               print('升级成功！')
            else:
               print('当前已达最高级别，无法进行升级！')
               super().manager(self.player,self.player)
               self.price_difference = self.pay3 - self.player
               self.player = self.pay3
         print(self.player,'工号：',self.upgrade_uid,'升级后职位:',self.player+str(self.player),'升级后薪资：',self.player,f'(+{self.price_difference})')
   else:
         print('该工号不存在！')
def degrade(self):
   self.degrade_uid = int(input('请输入工号：'))
   if self.degrade_uid in self.player:
         print(self.player,'工号：',self.degrade_uid,'当前职位:',self.player+str(self.player),'当前薪资：',self.player)
         self.de_grade = int(input('请输入需要减少的级数：'))
         if self.player == 'E':
            if self.de_grade < self.player:
               self.player = self.player - self.de_grade
               super().employee(self.player,self.player)
               self.price_difference = self.player - self.pay1
               self.player = self.pay1
               print('降级成功！')
            else:
               print('降级失败，超出级别范围！')
         elif self.player == 'T':
            if self.de_grade < self.player:
               self.player = self.player - self.de_grade
               super().teamleader(self.player,self.player)
               self.price_difference = self.player - self.pay2
               self.player = self.pay2
               print('降级成功！')
            else:
               self.player = 'E'
               self.player = 10
               super().employee(self.player,self.player)
               self.price_difference = self.player - self.pay1
               self.player = self.pay1
               print('降级成功！')
         elif self.player == 'M':
            if self.de_grade < self.player:
               self.player = self.player - self.de_grade
               super().manager(self.player,self.player)
               self.price_difference = self.player - self.pay3
               self.player = self.pay3
               print('降级成功！')
            else:
               self.player = 'T'
               self.player = 6
               super().teamleader(self.player,self.player)
               self.price_difference = self.player - self.pay2
               self.player = self.pay2
               print('降级成功！')
         print(self.player,'工号：',self.degrade_uid,'降级后职位:',self.player+str(self.player),'降级后薪资：',self.player,f'(-{self.price_difference})')
   else:
         print('该工号不存在！')

def main():
c = Function()
while True:
   print()
   temp = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
   if temp == '1':
         c.enroll()
   elif temp == '2':
         c.inquiry()
   elif temp == '3':
         c.upgrade()
   elif temp == '4':
         c.degrade()
   else:
         break

main()

qiao1316 发表于 2024-8-6 21:19:00

页: 9 10 11 12 13 14 15 16 17 18 [19] 20 21 22 23 24 25 26 27 28

鱼C论坛's Archiver