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

原野之风 发表于 2023-5-6 11:55:36

greetland 发表于 2023-5-6 10:23:57

学习

AZ5323 发表于 2023-5-5 20:42:41

tengke 发表于 2023-5-5 11:39:40

snowflyw 发表于 2023-5-5 09:11:41

1.根据不同的对象采取不同的操作
2.属于多态
4.降低了耦合度
5.不属于多态

hcm666 发表于 2023-5-4 17:51:06

# 0. 请按要求编写一个企业员工管理程序。
# 需要实现的要求：

class EmployeeM:
# b. 员工属性：姓名（name）、职位（job）、级别（grade）、工龄（year）、工号（uid）
name =None
job = None
grade = None
year = None
uid =None
# a. 员工分类：普通员工（Employee）、组长（Teamleader）、经理（Manager）
# c. 员工方法：
# get_uid() -- 获取工号
def set_uid(self,uid):
      self.uid=uid
def get_uid(self):
   returnself.uid
# get_name() -- 获取姓名
def set_name(self,name):
      self.name=name
def get_name(self):
   return self.name
# get_job() -- 获取职位
def set_job(self,job):
   dif = {'E': 'Employee', 'T': 'Teamleader', 'M': 'Manager'}
   self.job=job
def get_job(self):
   return self.job
# get_grade() -- 获取级别
def set_grade(self,grade):
         self.grade=grade
def get_grade(self):
   return self.grade
# get_year() -- 获取工龄
def set_year(self,year):
      self.year=year
def get_year(self):
   return self.year
# salary() -- 统计并返回工资（计算方法如下）
# d. 员工工资计算方法：
# 普通员工：3000 + 500 * 级别 + 50 * 工龄
# 组长：4000 + 800 * 级别 + 100 * 工龄
# 经理：5000 + 1000 * (级别 + 工龄)
def salary(self):
   if self.grade==1:
         self.salarysum=3000 + 500 * int(self.grade) + 50 * int(self.year)
   elif self.grade==2:
         self.salarysum = 4000 + 800 * int(self.grade) + 100 * int(self.year)
   else:
         self.salarysum = 5000 + 1000 * (int(self.grade) + int(self.year))
   return self.salarysum
# e. 程序功能：
class Manager:

def __init__(self):
   self.em = EmployeeM()
   self.idstart = 10000
   self.eee={}
# 录入员工数据功能（工号自动分配，由 10000 开始）
def inEmployee(self):
   name = 'hcm'
   self.em.set_name(name)
   job = 'M'
   self.em.set_job(job)
   grade = '7'
   self.em.set_grade(grade)
   year = '15'
   self.em.set_year(year)
   uid = self.idstart+1
   while uid in self.eee:
         uid = uid +1
   self.em.set_uid(uid)
   self.salarys = self.em.salary()
   self.eee=[self.em.get_name(),
                                 self.em.get_job(),
                                 self.em.get_grade(),
                                 self.em.get_year(),
                                 self.salarys]

   print(f'录入成功 name:{self.eee} '
         f'职称:{str(self.eee)+str(self.eee)}'
         f'工资:{self.salarys}')

   print('inEmployee',self.eee)
# 查询功能，分为员工查询和职位查询（见程序实现截图）
def checkEmployee(self):
   print('checkEmployee',self.eee)
   # self.uid =input('请输入UID')
   self.uid = '10001'
   print(int(self.uid) in self.eee)
   if int(self.uid) in self.eee:
         print(f'查询成功！ name:{self.eee} '
               f'职称:{str(self.eee) + str(self.eee)}'
               f'工资:{str(self.eee)}')
   else:
         print('UID不存在')

# 各类员工级别数量如下：
# 普通员工：10 级
# 组长：6 级
# 经理：3 级
# 升级功能：支持增加多级；当超过当前职位最高级别时，进行升职操作（无论增加多少个级别，只要发生升职，级别一律初始化为 1 级，见程序实现截图）.
def up_grade(self):
   print('up_grade', self.eee)
   # self.uid =input('请输入UID')
   self.uid = '10001'
   print(int(self.uid) in self.eee)
   if int(self.uid) in self.eee:
         self.eee=int(self.eee)+1
         print(f'升级成功！ name:{self.eee} '
               f'职称:{str(self.eee) + str(self.eee)}'
               f'工资:{str(self.eee)}')
   else:
         print('UID不存在')
# 降级功能：支持减少多级；当超过当前职位最高级别时，进行升职操作（无论减少多少个级别，只要发生降职，级别一律初始化为当前职位最高级别，见程序实现截图）
def down_grade(self):
   print('up_grade', self.eee)
   # self.uid =input('请输入UID')
   self.uid = '10001'
   print(int(self.uid) in self.eee)
   if int(self.uid) in self.eee:
         self.eee=int(self.eee)-1
         print(f'降级成功！ name:{self.eee} '
               f'职称:{str(self.eee) + str(self.eee)}'
               f'工资:{str(self.eee)}')
   else:
         print('UID不存在')
m = Manager()
m.inEmployee()
m.checkEmployee()
m.up_grade()
m.down_grade()

条纹领带 发表于 2023-5-4 10:17:04

非常感谢

mlxdmo 发表于 2023-5-4 00:28:44

。。。

机器学习东东 发表于 2023-5-3 15:33:02

爱睡懒觉 发表于 2023-5-3 11:25:43

0。给函数传递不同的实例对象
1.只需要要一个函数就能调用不同类的方法
2.可以
3.鸭鸭这么可爱，为什么要吃鸭鸭
4.增强内聚
5.不是
0.
class Member:
def __init__(self):
   self.names = []
   self.jobs = {}
   self.grades = {}
   self.years = {}
   self.uids = {}
   self.salarys = {}
   self.counts = 0
class SalaryMixin:
def salary(self,grade,year,job):
   if job == "E":
         return 3000+500*int(grade)+50*int(year)
   if job == "T":
         return 4000+800*int(grade)+100*int(year)
   if job == "M":
         return 5000+1000*(int(grade)+int(year))
class Manage:
def log_in(self):
   m = Member()
   s = SalaryMixin()
   num = 10000 + self.counts
   name = input("姓名:")
   while name in m.names:
         name = input("该姓名已存在，请重新录入:")
   else:
         m.names.append(name)
   m.uids = num
   job = input("职位(E.普通员工;T.组长;M.经理):")
   m.jobs = job
   year = input("工龄:")
   m.years = year
   grade = input("级别")
   if job == "E":
         while int(grade) > 10 or int(grade) < 1:
            grade = input("级别不正确，请重新输入:")
   if job == "T":
         while int(grade) > 6 or int(grade) < 1:
            grade = input("级别不正确，请重新输入:")
   if job == "M":
         while int(grade) > 3 or int(grade) < 1:
            grade = input("级别不正确，请重新输入:")
   m.grades = grade
   self.counts += 1
   salary = s.salary(grade,year,job)
   m.salarys = salary
   print(f"录入成功!姓名:{name},工号:{num},薪资:{salary}")
def staff_search(self):
   m =Member()
   uid = input("请输入工号")
   try:
         name = m.names)]
         job = m.jobs + m.grades
         salary = m.salarys
   except:
         print("该员工不存在")
   else:
         print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}")
def job_search(self):
   m = Member()
   job = input("职位(E.普通员工;T.组长;M.经理):")
   sums = 0
   _ = []
   if job == "E":
         for each in m.names:
            if m.jobs == "E":
               sums += 1
               _.append
            print(f"当前普通员工共有{sums}人")
            for each in _:
               print(f"{m.uids}-each")
   if job == "T":
         for each in m.names:
            if m.jobs == "T":
               sums += 1
               _.append
            print(f"当前组长共有{sums}人")
            for each in _:
               print(f"{m.uids}-each")
   if job == "M":
         for each in m.names:
            if m.jobs == "M":
               sums += 1
               _.append
            print(f"当前经理共有{sums}人")
            for each in _:
               print(f"{m.uids}-each")
def upgrade(self):
   m = Member()
   s = SalaryMixin()
   uid = input("请输入工号:")
   sums = 0
   try:
         name = m.names)]
         job = m.jobs + m.grades
         salary = m.salarys
   except:
         print("该员工不存在")
   else:
         print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}")
   if m.jobs == "E":
         grade = input("请输入需要增加的级数")
         sums = int(m.grades) + int(grade)
         while sums > 19:
            grade = input("级别错误，请输入需要增加的级数")
            sums = int(m.grades) + int(grade)
         else:
            if sums < 11:
               print("升级成功")
               salary = int(salary) + 500 * int(grade)
               job = m.jobs + str(sums)
               print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}")
            if sums > 10 and sums < 17:
               print("升级成功")
               salary = s.salary(sums-10,m.years,"T")
               job = "T"+str(sums-10)
               print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}")
            if sums > 16 and sums < 20:
               print("升级成功")
               salary = s.salary(sums-16,m.years,"M")
               job = "M"+str(sums-16)
               print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}")
   if m.jobs == "T":
         grade = input("请输入需要增加的级数")
         sums = int(m.grades) + int(grade)
         while sums > 9:
            grade = input("级别错误，请输入需要增加的级数")
            sums = int(m.grades) + int(grade)
         else:
            if sums < 4:
               print("升级成功")
               salary = int(salary) + 800 * int(grade)
               job = m.jobs + str(sums)
               print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}
            if sums > 3 and sums < 10:
               print("升级成功")
               salary = s.salary(sums-3,m.years,"M")
               job = "M"+str(sums-3)
               print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}
   if m.jobs == "M":
         grade = input("请输入需要增加的级数")
         sums = int(m.grades) + int(grade)
         while sums > 3:
            grade = input("级别错误，请输入需要增加的级数")
            sums = int(m.grades) + int(grade)
         else:
            print("升级成功")
            salary = int(salary) + 1000 * int(grade)
            job = m.jobs + str(sums)
            print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}
def downgrade(self):
   m = Member()
   s = SalaryMixin()
   uid = input("请输入工号:")
   sums = 0
   try:
         name = m.names)]
         job = m.jobs + m.grades
         salary = m.salarys
   except:
         print("该员工不存在")
   else:
         print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}")
   if m.jobs == "E":
         grade = input("请输入需要减少的级数")
         sums = int(m.grades) - int(grade)
   while sums < 1:
            grade = input("级别错误，请输入需要增加的级数")
            sums = int(m.grades) + int(grade)
   else:
         print("降级成功")
         salary = int(salary) - 500 * int(grade)
         job = m.jobs + str(sums)
         print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}")
      if m.jobs == "T":
         grade = input("请输入需要减少的级数")
         sums = int(m.grades) - int(grade) + 10
         while sums < 1:
            grade = input("级别错误，请输入需要增加的级数")
            sums = int(m.grades) + int(grade)
         else:
            if sums > 10:
               print("降级成功")
               salary = int(salary) - 800 * int(grade)
               job = m.jobs + str(sums)
               print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}")
            if sums < 11:
               print("降级成功")
               salary = s.salary(sums,m.years,"E")
               job = "E"+str(sums)
               print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}")
      if m.jobs == "M":
         grade = input("请输入需要减少的级数")
         sums = int(m.grades) - int(grade) + 16
         while sums < 1:
            grade = input("级别错误，请输入需要增加的级数")
            sums = int(m.grades) + int(grade)
         else:
            if sums > 16:
               print("降级成功")
               salary = int(salary) - 1000 * int(grade)
               job = m.jobs + str(sums)
               print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}")
            if sums > 10 and sums < 17:
               print("降级成功")
               salary = s.salary(sums-10,m.years,"T")
               job = "T"+str(sums-10)
               print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}")
            if sums < 11:
               print("降级成功")
               salary = s.salary(sums,m.years,"E")
               job = "E"+str(sums)
               print(f"{name},工号:{uid},当前职位:{job},当前薪资:{salary}")
while True:
command = input("1.录入;2.查询；3.升级;4.降级;5.退出:")
m = Manage()
if command == "1":
   m.log_in()
if command == "2":
   search = input("1.员工查询;2.职位查询:")
   if search == "1":
         m.staff_search()
   else:
         m.job_search()
if command == "3":
   m.upgrade()
if command == "4":
   m.downgrade()
if command == "5":
   break

canfeng0522 发表于 2023-5-2 16:35:07

{:10_264:}

龙葵的龙葵 发表于 2023-5-2 09:51:20

0）
1）尽管我们的接口是不变的，但它却可以根据不同的对象执行不同的操作
2）不可以
3）
4）降低了耦合度
5）是

暮雨朝云 发表于 2023-4-27 15:58:36

{:5_102:}

可食用小柠檬 发表于 2023-4-25 09:47:45

colinl 发表于 2023-4-24 20:18:45

何惧123 发表于 2023-4-24 11:32:32

{:5_90:}

kakalu5083 发表于 2023-4-22 16:22:20

录入查询升级降级

fdfc123 发表于 2023-4-22 14:05:08

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.salary=self.get_salary()
def get_uid(self):
   pass
def get_name(self):
   pass
def get_job(self):
   pass
def get_grade(self):
   pass
def get_year(self):
   pass
def get_salary(self):
   if self.job=='E':
         return 3000+500*self.grade+50*self.year
   elif self.job=='T':
         return 4000+800*self.grade+100*self.year
   else:
         return 5000+1000*(self.grade+self.year)
class Manage:
def __init__(self):
   self.members={}
   self.count=10000
def opening(self):
   s=0
   while s!='5':
         s=input("1.录入；2.查询；3.升级；4.降级；5.退出：")
         if s=='1':
            self.create()
         elif s=='2':
            self.search()
         elif s=='3':
            self.upgrade()
         elif s=='4':
            self.degrade()
def create(self):
   name=input("姓名：")
   job=input( "职位（E.普通员工；T.组长；M.经理）：")
   year=int(input("工龄："))
   grade=self.check_grade(job)
   self.members=Employee(name,job,grade,year,self.count)
   print(f"录入成功！姓名：{name},工号：{self.count},薪资：{self.members.salary}")
   self.count+=1
def search(self):
   c=input("1.员工查询；2.职位查询：")
   if c=='1':
         uid=int(input("请输入工号："))
         if uid not in self.members:
            print("该工号不存在！")
         else:
            print(f"姓名：{self.members.name}")
            print(f"职位：{self.members.job}")
            print(f"级别：{self.members.grade}")
            print(f"工龄：{self.members.year}")
            print(f"工资：{self.members.salary}")
   else:
         job=input("职位（E.普通员工；T.组长；M.经理）：")
         nums=0
         ls=[]
         for i in self.members:
            if self.members.job==job:
               nums+=1
               ls.append(f"{self.members.uid}-{self.members.name}")
         if nums:
            print(f"目前{job}共有{nums}人")
            print('\n'.join(ls))
         else:
            print(f"目前公司没有{job}！")
def check_grade(self,job):
   grade=int(input("级别："))
   while True:
         if job=='E' and grade>10:
            grade=int(input("该职位最高级别为10，请重新录入级别："))
         elif job=='T' and grade>6:
            grade=int(input("该职位最高级别为6，请重新录入级别："))
         elif job=='M' and grade>3:
            grade=int(input("该职位最高级别为3，请重新录入级别："))
         else:
            return grade
def upgrade(self):
   uid=int(input("请输入工号："))
   ins=self.members
   print(f"{ins.name},工号：{ins.uid},当前职位：{ins.job}{ins.grade},当前薪资：{ins.salary}")
   adds=int(input("请输入需要增加的级数："))
   if ins.job=='E':
         if ins.grade+adds>10:
            ins.grade=1
            ins.job='T'
         else:
            ins.grsde+=adds
   elif ins.job=='T':
         if ins.grade+adds>6:
            ins.grade=1
            ins.job='M'
         else:
            ins.grsde+=adds
   else:
         ins.grade+=adds
   old_salary=ins.salary
   ins.salary=ins.get_salary()
   print("升级成功")
   print(f"{ins.name},工号：{ins.uid},升级后职位：{ins.job}{ins.grade},升级后薪资：{ins.salary}(+{ins.salary-old_salary})")
def degrade(self):
   uid=int(input("请输入工号："))
   ins=self.members
   print(f"{ins.name},工号：{ins.uid},当前职位：{ins.job}{ins.grade},当前薪资：{ins.salary}")
   drops=int(input("请输入需要减少的级数："))
   if ins.job=='M':
         if ins.grade-drops<0:
            ins.grade=6
            ins.job='T'
         else:
            ins.grsde-=drops
   elif ins.job=='T':
         if ins.grade-drops>0:
            ins.grade=10
            ins.job='E'
         else:
            ins.grsde-=drops
   else:
         ins.grade-=drops
   old_salary=ins.salary
   ins.salary=ins.get_salary()
   print("降级成功")
   print(f"{ins.name},工号：{ins.uid},降级后职位：{ins.job}{ins.grade},降级后薪资：{ins.salary}({ins.salary-old_salary})")

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

main()

Irena 发表于 2023-4-21 09:41:05

{:5_91:}

黑猫小肥 发表于 2023-4-18 14:54:16

看答案

页: 27 28 29 30 31 32 33 34 35 36 [37] 38 39 40 41 42 43

鱼C论坛's Archiver