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

Spruance117 发表于 2023-3-6 17:43:48

2. 可以
5. 不是
输入对象都是 int 类的变量只是 z是否按默认取值

0.
def main():
index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
uid = 9999
worker =
while index!=5:
   if index == 1:
         name = input("姓名：")
         job = input("职位（E.普通员；T.组长；M.经理）：")
         if job == 'E':
            max_grade = 10
         elif job == 'T':
            max_grade = 6
         elif job == 'M':
            max_grade = 3
         year = int(input("工龄："))
         grade = int(input("级别："))
         while grade>max_grade:
            grade = int(input(f"该职位最高级别为{max_grade}，请重新录入级别："))


         uid += 1
         worker.append(0)
         worker = Worker(name,job,grade,year,uid)
         print(f"录入成功！姓名：{worker.name},工号：{uid},资薪：{worker.salary()}")
         index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))

   elif index == 2:
         check = int(input("1.员工查询；2.职位查询："))
         if check == 1:
            _ = int(input("请输入工号："))
            if _>len(worker)-1 or _<10000:
               print("该员工不存在!")
               index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
            else:
               worker.worker_inquire()
               index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
         elif check == 2:
            job_ = input("职位（E.普通员；T.组长；M.经理）：")
            sum1 = sum( if i.job == job_])
            if sum1 == 0:
               if job_ == 'E':
                     print("目前公司没有普通员工")
               elif job_ == 'T':
                     print("目前公司没有组长")
               elif job_ == 'M':
                     print("目前公司没有经理")
            else:
               if job_ == 'E':
                     print("目前普通员工共有{}人".format(sum1))
               elif job_ == 'T':
                     print("目前组长共有{}人".format(sum1))
               elif job_ == 'M':
                     print("目前经理共有{}人".format(sum1))
               for _ in worker:
                     if _.job == job_:
                        print(_.uid," - ",_.name)
            index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))

   elif index == 3:
         uid_ = int(input("请输入工号："))
         if uid_>len(worker)-1 or uid_<10000:
            print("该员工不存在!")
            index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
         else:
            print(f"{worker.name}，工号：{worker.uid}，当前职位：{worker.job}{worker.grade}，当前资薪：{worker.salary()}")
            temp = worker.salary()


            add_grade = int(input("请输入需要增加的级数："))
            if worker.job == 'E':
               max_grade = 10
               if add_grade + worker.grade > max_grade:
                     worker.job = 'T'
                     worker.grade = 1
               else:
                     worker.grade = add_grade + worker.grade

            elif worker.job == 'T':
               max_grade = 6
               if add_grade + worker.grade > max_grade:
                     worker.job = 'M'
                     worker.grade = 1
               else:
                     worker.grade = add_grade + worker.grade

            elif worker.job == 'M':
               max_grade = 3
               if add_grade + worker.grade > max_grade:
                     print("没有这个级别")
                     index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
               else:
                     worker.grade = add_grade + worker.grade

            print("升级成功！")
            print(f"{worker.name}，工号：{worker.uid}，升级后职位：{worker.job}{worker.grade}，升级后资薪：{worker.salary()}(+{worker.salary()-temp})")



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

   elif index == 4:
         uid_ = int(input("请输入工号："))
         if uid_>len(worker)-1 or uid_<10000:
            print("该员工不存在!")
            index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
         else:
            print(f"{worker.name}，工号：{worker.uid}，当前职位：{worker.job}{worker.grade}，当前资薪：{worker.salary()}")
            temp = worker.salary()

            add_grade = int(input("请输入需要减少的级数："))
            if worker.job == 'M':
               min_grade = 1
               ifworker.grade - add_grade < min_grade:
                     worker.job = 'T'
                     worker.grade = 6
               else:
                     worker.grade = worker.grade - add_grade

            elif worker.job == 'T':
               min_grade = 1
               if aworker.grade - add_grade < min_grade:
                     worker.job = 'E'
                     worker.grade = 10
               else:
                     worker.grade = worker.grade - add_grade

            elif worker.job == 'E':
               min_grade = 1
               if worker.grade - add_grade < min_grade:
                     print("没有这个级别")
                     index = int(input("1.录入；2.查询；3.升级；4.降级；5.退出："))
               else:
                     worker.grade = worker.grade - add_grade

         print("降级成功！")
         print(f"{worker.name}，工号：{worker.uid}，降级后职位：{worker.job}{worker.grade}，降级后资薪：{worker.salary()}({worker.salary()-temp})")


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

class Worker:
def __init__(self,name=None,job=None,grade=None,year=None,uid=None):
   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 * 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)

def worker_inquire(self):
   print(f"姓名：{self.name}")
   print(f"职位：{self.job}")
   print(f"级别：{self.grade}")
   print(f"工龄：{self.year}")
   print(f"薪资：{self.salary()}")

haaljw 发表于 2023-3-6 15:53:02

TZ小宿 发表于 2023-3-4 09:58:38

我曾经跨过山和大海

exileddesperado 发表于 2023-3-3 17:15:54

0. 不同类的对象均可使用同一种方法
1. 利用多态可以让不同类的对象执行同一种方法
2. 可以
3.
4. 增强内聚
5. 不属于

0.
uids = iter(range(10000, 100000))
uid_used = []
employees = []

def get_uid(uids):
uid = int(input("请输入工号："))
while uid not in uids:
   uid = int(input("工号不存在，请重新输入："))
return uid

class infoMixin:
def info(self, name, job, grade, year, uid):
   self.name = name
   self.job = job
   self.grade = grade
   self.year = year
   self.uid = uid

class checkMixin:
def check_grade(self):
   if self.job == "E":
         if self.grade > 10 or self.grade < 0:
            self.grade = int(input("超过范围，该职位级别为1~10，请重新输入："))
   elif self.job == "T":
         if self.grade > 6 or self.grade < 0:
            self.grade = int(input("超过范围，该职位级别为1~6，请重新输入："))
   elif self.job == "M":
         if self.grade > 3 or self.grade < 0:
            self.grade = int(input("超过范围，该职位级别为1~3，请重新输入："))

def up_grade(self, x):
   if self.job == "E":
         if x + self.grade > 10:
            self.job = "T"
            self.grade = 1
         else:
            self.grade += x
   elif self.job == "T":
         if x + self.grade > 6:
            self.job = "M"
            self.grade = 1
         else:
            self.grade += x
   else:
         while x + self.grade > 3:
            x = int(input("超过范围，该职位级别为1~3，请重新输入："))
         self.grade += x

def down_grade(self, x):
   if self.job == "M":
         if self.grade - x <= 0:
            self.job = "T"
            self.grade = 6
         else:
            self.grade -= x
   elif self.job == "T":
         if self.grade - 2 <= 0:
            self.job = "E"
            self.grade = 10
         else:
            self.grade -= x
   else:
         while x + self.grade <= 0:
            x = int(input("超过范围，该职位级别为1~10，请重新输入："))
         self.grade -= x

class toolMixin:
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 * 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 Employee(infoMixin, checkMixin, toolMixin):
def __init__(self, name, job, grade, year, uid):
   super().info(name, job, grade, year, uid)
   super().check_grade()

class Teamleader(infoMixin, checkMixin, toolMixin):
def __init__(self, name, job, grade, year, uid):
   super().info(name, job, grade, year, uid)
   super().check_grade()

class Manager(infoMixin, checkMixin, toolMixin):
def __init__(self, name, job, grade, year, uid):
   super().info(name, job, grade, year, uid)
   super().check_grade()

class Manage:
def greet(self):
   command = input("1.录入；2.查询；3.升级；4.降级；5.退出")
   return command

def register(self):
   name = input("姓名：")
   job = input("职位（E.普通员工；T.组长；M.经理）：")
   year = int(input("工龄："))
   grade = int(input("级别："))
   uid = next(uids)
   if job == "E":
         employees.append(Employee(name, job, year, grade, uid))
   elif job == "T":
         employees.append(Teamleader(name, job, year, grade, uid))
   elif job == "M":
         employees.append(Manager(name, job, year, grade, uid))
   uid_used.append(uid)

def search(self):
   command = input("1.员工查询；2.职位查询：")
   if command == "1":
         uid = get_uid(uid_used)
         for each in employees:
            if each.uid == uid:
               print(f"姓名：{each.get_name()}\n职位：{each.get_job()}\n级别：{each.get_grade()}\n工龄：{each.get_year()}\n薪资：{each.salary()}")
               break
   elif command == "2":
         job = input("请输入职位（E.普通员工；T.组长；M.经理）：")
         count = 0
         p =
         if job == "E":
            print(f"目前普通员工共{len(p)}人：")
         elif job == "T":
            print(f"目前组长共{len(p)}人：")
         else:
            print(f"目前经理共{len(p)}人：")
         for each in p:
            print(f"{each.uid} --{each.name}")

def upgrade(self):
   uid = get_uid(uid_used)
   for each in employees:
         if each.uid == uid:
            print(f"{each.name},工号：{each.uid},当前职位：{each.job}{each.grade}，当前薪资：{each.salary()}")
            x = int(input("请输入需要增加的级数："))
            y = each.salary()
            each.up_grade(x)
   print("升级成功！")
   print(f"{each.name},工号：{each.uid},升级后职位：{each.job}{each.grade}，升级后薪资：{each.salary()}(+{each.salary() - y})")

def downgrade(self):
   uid = get_uid(uid_used)
   for each in employees:
         if each.uid == uid:
            print(f"{each.name},工号：{each.uid},当前职位：{each.job}{each.grade}，当前薪资：{each.salary()}")
            x = int(input("请输入需要降低的级数："))
            y = each.salary()
            each.down_grade(x)
   print("降级成功！")
   print(f"{each.name},工号：{each.uid},降级后职位：{each.job}{each.grade}，降级后薪资：{each.salary()}(-{y - each.salary()})")

def main():
manage = Manage()
while 1:
   command = manage.greet()
   if command == "1":
         manage.register()
   elif command == "2":
         manage.search()
   elif command == "3":
         manage.upgrade()
   elif command == "4":
         manage.downgrade()
   elif command == "5":
         break

main()

zhangqinwu 发表于 2023-3-3 09:28:18

看答案

哈喽你好年 发表于 2023-3-2 16:50:18

答案

xnl3998 发表于 2023-3-2 16:46:48

0.允许在子类中定义与父类相同名字的方法
1.可以运算符的多态
2.不知道
4.增强内聚
5.不属于吧

意阑珊 发表于 2023-2-27 15:50:11

class level_optMixin:
def level_max(self,job):
   if job == 'E':
         return 10
   elif job == 'T':
         return 6
   elif job == 'M':
         return 3
def level_judge(self,level,level_max):
   while level >level_max:
         level = int(input(f'该职位最高级别为{level_max},请重新录入级别:'))
   return level

class Employee:
def __init__(self,name,job,level,year,uid,salary):
   self.name = name
   self.job = job
   self.level = level
   self.year = year
   self.uid = uid
   self.salary = salary

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_uid(self):
   return self_uid

class Job_statistic:

def statistic(self,job,employees):
   temp = {}
   count = 0
   for each in employees:
         if self.employees.job == job:
            count +=1
            temp = self.employees.name

   if job == 'E':
         print(f'目前普通员工共有{count}人：')
   elif job == 'T':
         print(f'目前组长共有{count}人：')
   elif job == 'M':
         print(f'目前经理共有{count}人：')

   if len(temp) == 0:
         print('目前公司没有该职位')
   else:
         for each in temp:
            print(f'{each}-{temp}')

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

class Manage(level_optMixin,Salary,Job_statistic):
def __init__(self):
   self.employees = {}
   self.uid = 10000
   self.job_list = ['E','T','M']

def inputorder(self):
   while True:
         order = int(input('\n1.录入；2.查询；3.升级；4.降级；5.退出：'))


         if order == 1:
            self.create_e()
            self.uid +=1
            continue
         elif order == 2:
            self.searching()
            continue
         elif order == 3:
            self.level_up()
            continue
         elif order == 4:
            self.level_down()
            continue
         elif order == 5:
            break


def create_e(self):
   name = input('姓名：')

   job = input('(E.普通员工;T.组长;M.经理):')

   year = int(input('工龄:'))

   level = int(input('级别:'))
   level_max = self.level_max(job)
   level = self.level_judge(level,level_max)

   salary = self.output_salary(job,year,level)

   self.employees = Employee(name,job,level,year,self.uid,salary)

   print(f'录入成功！姓名:{name},工号:{self.uid},薪资:{salary}')

def searching(self):
   order_0 = int(input('1.员工查询;2.职位查询:'))

   if order_0 == 1:
         uid_searching = int(input('请输入工号:'))
         if self.employees.get(uid_searching):
            print(f'姓名:{self.employees.get(uid_searching).name}')
            print(f'职位:{self.employees.get(uid_searching).job}')
            print(f'级别:{self.employees.get(uid_searching).level}')
            print(f'工龄:{self.employees.get(uid_searching).year}')
            print(f'薪资:{self.employees.get(uid_searching).salary}')
         else:
            print('该工号不存在')
   elif order_0 == 2:
         job_searching = input('(E.普通员工;T.组长；M.经理):')

         self.statistic(job_searching,self.employees)

def level_up(self):
   uid_searching = int(input('请输入工号:'))
   if self.employees.get(uid_searching):
         print(f'{self.employees.get(uid_searching).name},\
工号{uid_searching},当前职位{self.employees.get(uid_searching).job}\
{self.employees.get(uid_searching).level},当前薪资\
{self.employees.get(uid_searching).salary}')

         job = self.employees.get(uid_searching).job
         level = self.employees.get(uid_searching).level

         index = self.job_list.index(job)

         level_max = self.level_max(job)
         level_up = int(input('请输入需要增加的级数:'))

         salary_old = self.employees.get(uid_searching).salary

         if level + level_up > level_max:
            job = self.job_list
            level = 1
         else:
            level +=level_up

         year = self.employees.get(uid_searching).year

         salary_new = self.output_salary(job,year,level)

         self.employees.get(uid_searching).job = job
         self.employees.get(uid_searching).level = level
         self.employees.get(uid_searching).salary = salary_new
         print(f'{self.employees.get(uid_searching).name},\
工号{uid_searching},升级后职位{self.employees.get(uid_searching).job}\
{self.employees.get(uid_searching).level},\
升级后薪资{salary_new}({salary_new-salary_old})')

def level_down(self):
   uid_searching = int(input('请输入工号:'))
   if self.employees.get(uid_searching):
         print(f'{self.employees.get(uid_searching).name},\
工号{uid_searching},当前职位{self.employees.get(uid_searching).job}\
{self.employees.get(uid_searching).level},当前薪资\
{self.employees.get(uid_searching).salary}')

         job = self.employees.get(uid_searching).job
         level = self.employees.get(uid_searching).level

         index = self.job_list.index(job)

         salary_old = self.employees.get(uid_searching).salary

         level_down = int(input('请输入需要减少的级数:'))
         if level - level_down < 1:
            job = self.job_list
            level = self.level_max(job)
         else:
            level -=level_down

         year = self.employees.get(uid_searching).year

         self.employees.get(uid_searching).job = job
         self.employees.get(uid_searching).level = level
         salary_new = self.output_salary(job,year,level)

         print(f'{self.employees.get(uid_searching).name},\
工号{uid_searching},降级后职位{self.employees.get(uid_searching).job}\
{self.employees.get(uid_searching).level},\
降级后薪资{salary_new}({salary_new-salary_old})')


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

main()

白いバラの夜 发表于 2023-2-26 14:58:18

bozhen 发表于 2023-2-24 12:13:24

import sys

class Person:
uid = 10000
person_list = []

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

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':
         self.money =3000 + 500 * self.grade + 50 * self.year
   elif self.job == 'T':
         self.money =4000 + 800 * self.grade + 100 * self.year
   elif self.job == 'M':
         self.money =5000 + 1000 * (self.grade + self.year)

class Employee(Person):
def __init__(self,name, job, grade, year, uid):
   super().__init__(name, job, grade, year, uid)
   self.job = 'E'
   self.grade_max = 10

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

class Teamleader(Person):
def __init__(self,name, job, grade, year, uid):
   super().__init__(name, job, grade, year, uid)
   self.job = 'T'
   self.grade_max = 6

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

class Manager(Person):
def __init__(self,name, job, grade, year, uid):
   super().__init__(name, job, grade, year, uid)
   self.job = 'M'
   self.grade_max = 3

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

def add():
name = input('姓名:')
job = input('职位（E.普通员工；T.组长；M.经理）:')
year = int(input('工龄:'))
grade = int(input('级别:'))
if job == 'E':
   p = Employee(name, job, grade, year, Person.uid)
   if p.grade > p.grade_max:
         p.grade = int(input(f'该职位最高级别为{p.grade_max},请重新输入级别:'))
         p.salary()
elif job == 'T':
   p = Teamleader(name, job, grade, year, Person.uid)
   if p.grade > p.grade_max:
         p.grade = int(input(f'该职位最高级别为{p.grade_max},请重新输入级别:'))
         p.salary()
elif job == 'M':
   p = Manager(name, job, grade, year, Person.uid)
   if p.grade > p.grade_max:
         p.grade = int(input(f'该职位最高级别为{p.grade_max},请重新输入级别:'))
p.money = p.salary()
Person.person_list.append(p)
print(f'录入成功！姓名:{p.name},工号:{Person.uid},薪资:{p.money}')
Person.uid += 1

def search():
res = int(input('1.员工查询；2.职位查询：'))
if res == 1:
   uid = int(input('请输入工号:'))
   for p in Person.person_list:
         if uid == p.uid:
            print(f'姓名： {p.name}')
            print(f'职位： {p.job}')
            print(f'级别： {p.grade}')
            print(f'工龄： {p.year}')
            print(f'薪资： {p.money}')
            break
   else:
         print('该工号不存在!')
elif res == 2:
   res = input('职位(E.普通员工；T.组长；M.经理)：')
   if res == "E":
         p_lst = []
         for p in Person.person_list:
            if p.job == res:
               p_lst.append(p)
         print(f'目前普通员工共有 {len(p_lst)} 人')
         for p in p_lst:
            print(f'{p.uid} - {p.name}')
         if len(p_lst) == 0:
            print('目前公司没有普通员工！')
   elif res == 'T':
         p_lst = []
         for p in Person.person_list:
            if p.job == res:
               p_lst.append(p)
         print(f'目前组长共有 {len(p_lst)} 人')
         for p in p_lst:
            print(f'{p.uid} - {p.name}')
         if len(p_lst) == 0:
            print('目前公司没有组长！')
   elif res == 'M':
         p_lst = []
         for p in Person.person_list:
            if p.job == res:
               p_lst.append(p)
         print(f'目前经理共有 {len(p_lst)} 人')
         for p in p_lst:
            print(f'{p.uid} - {p.name}')
         if len(p_lst) == 0:
            print('目前公司没有经理！')

def upgrade():
uid = int(input('请输入工号:'))

for p in Person.person_list:
   if p.name == uid:
         m1 = int(p.money)
         print(f'{p.name},工号: {uid},当前职位:{p.job}{p.grade},当前薪资：{p.money}')
         grade = int(input('请输入需要增加的级数:'))
         p.grade = p.grade + grade
         if p.grade > p.grade_max:
            if p.job == 'E':
               p.job = 'T'
               p.grade = p.grade - p.grade_max
            elif p.job == 'T':
               p.job = 'M'
               p.grade = p.grade - p.grade_max
         p.salary()
         m2 = int(p.money)
         print('升级成功')
         print(f'{p.name},工号: {uid},升级后职位职位:{p.job}{p.grade},升级后薪资：{p.money}(+{m2-m1})')

def downgrade():
uid = int(input('请输入工号:'))
for p in Person.person_list:
   if p.name == uid:
         m1 = int(p.money)
         print(f'{p.name},工号: {uid},当前职位:{p.job}{p.grade},当前薪资：{p.money}')
         grade = int(input('请输入需要减少的级数:'))
         p.grade = p.grade - grade
         if p.grade < 0:
            if p.job == 'T':
               p.job = 'E'
               p.grade = p.grade_max - p.grade
            elif p.job == 'M':
               p.job = 'T'
               p.grade = p.grade_max - p.grade
         p.salary()
         m2 = int(p.money)
         print('降级成功')
         print(f'{p.name},工号: {uid},降级后职位:{p.job}{p.grade},降级后薪资：{p.money}(-{m2 - m1})')
         break

def main():
while True:
   res = int(input('\n1.录入；2.查询；3.升级；4.降级；5.退出:'))
   if res == 1:
         add()
   elif res == 2:
         search()
   elif res == 3:
         upgrade()
   elif res == 4:
         downgrade()
   elif res == 5:
         break

if __name__ == '__main__':
main()

啊啊小姐姐 发表于 2023-2-23 11:10:13

一定要努力！！ 发表于 2023-2-23 11:08:48

小乌龟1 发表于 2023-2-22 15:16:05

写个简单的偷懒啦
class yuangong():
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
class employees(yuangong):
def __init__(self,name,job,grade,year,uid):
   super().__init__(name,job,grade,year,uid)
def salary(self):
   return 3000 + 500*self.grade+50*self.year
class teamleader(yuangong):
def __init__(self,name,job,grade,year,uid):
   super().__init__(name,job,grade,year,uid)
def salary(self):
   return 4000+800*self.grade+100*self.year
class manager(yuangong):
def __init__(self,name,job,grade,year,uid):
   super().__init__(name,job,grade,year,uid)
def salary(self):
   return 5000 + 1000*(self.grade+self.year)

class Manager_min():
def __init__(self):
   self.employee = {}
   self.uid = 10000
def welcom(self):
   print('欢迎使用员工管理系统')
   while 1 :
         ins = input('请输入您的命令：1.增加员工 2.查询 3.升级 4.降级 5.退出')
         if ins == '1':
            self.create_yuangong()
         elif ins == '2':
            self.select()
         elif ins == '3':
            pass
         elif ins == '4':
            pass
         elif ins == '5':
            print('感谢使用员工管理系统，再见！')
            break
         else :
            print('你输入的密码不正确 ',end = '')
def create_yuangong(self):
   name = input('请输入员工名称')
   job = input('职位（E员工 T组长 M经理）')
   year = int(input('工龄'))
   grade = int(input('级别'))

   if job == 'E':
         employee = employees(name,job,grade,year,self.uid)
         self.employee = employee

   elif job == 'T':
         employee = teamleader(name,job,grade,year,self.uid)
         self.employee = employee

   else:
         employee = manager(name,job,grade,year,self.uid)
         self.employee = employee
   self.uid += 1
def select(self):
   uid = int(input('请输入你要查询的员工号'))
   while uid not in self.employee:
         uid = int(input('你输入的员工号不存在，请重新输入'))
   print(f'姓名：{self.employee.name}\n职位：{self.employee.job}\n级别：{self.employee.job}\n工龄：{self.employee.year}\n薪资：{self.employee.salary()}')

def main():
main = Manager_min()
main.welcom()

main()

deep-cy 发表于 2023-2-21 16:52:54

jack6666 发表于 2023-2-20 21:15:56

zzZzmmming 发表于 2023-2-20 11:39:04

0.同名方法，在不同类中的功能不一样
1.不同对象中的计算长度的函数可以用一个len（）就解决
2.不能
3.
4.增强了内聚，降低了耦合
5.不是

yk272424127 发表于 2023-2-19 16:29:06

0.
方法的作用在不同状况下各不相同
1.

2.
可以
3.

4.
降低藕合
5.
不能

动动手：
class JobMixin:
def shift_en(self, job):
   if job == 'E':
         return 'Employee'
   elif job == 'T':
         return 'Teamleader'
   elif job == 'M':
         return 'Manager'

def shift_cn(self, job):
   if job == 'E':
         return "普通员工"
   elif job == 'T':
         return "组长"
   elif job == 'M':
         return "经理"

def up_down(self, job, grade):
   job_id = {'Employee': 0, 'Teamleader': 1, 'Manager': 2}
   job_name = ['Employee', 'Teamleader', 'Manager']
   grade_scope = {'Employee': 10, 'Teamleader': 6, 'Manager': 3}
   id = job_id
   scope = grade_scope
   if grade > scope:
         if id == 2:
            grade = scope
         else:
            grade = 1
            id += 1
            job = job_name
   if grade < 0:
         if id == 0:
            grade = 1
         else:
            id -= 1
            job = job_name
            grade = grade_scope
   return job, grade

def check(self, x, y='job'):
   if isinstance(x, str):
         while x not in ['E', 'T', 'M']:
            x = input("请输入正确的职位（E.普通员工；T.组长；M.经理）：")
   elif isinstance(x, int):
         grade_scope = {'Employee': 10, 'Teamleader': 6, 'Manager': 3}
         scope = grade_scope
         while x not in range(scope+1):
            x = int(input(f"该职位最高级别为{scope}，请重新录入级别："))
   return x

class Staff:
def __init__(self, name, job, year, grade, uid):
   self.name = name
   self.job = job
   self.year = year
   self.grade = grade
   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 == 'Employee':
         return 3000 + 500 * self.grade + 50 * self.year
   elif self.job == 'Teamleader':
         return 4000 + 800 * self.grade + 100 * self.year
   elif self.job == 'Manager':
         return 5000 + 1000 * (self.grade + self.year)

class Manage(JobMixin):
def __init__(self):
   self.members = {}
   self.job = {'Employee': {}, 'Teamleader': {}, 'Manager': {}}
   self.uid = 10000

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

def inquire(self):
   order = int(input("1.工人查询；2.职位查询："))
   if order == 1:
         uid = int(input("请输入工号："))
         if uid in self.members:
            play = self.members
            salary = play.salary()
            print(f"姓名：{play.name}\n"
                  f"职位：{play.job}\n"
                  f"级别：{play.grade}\n"
                  f"工龄：{play.year}\n"
                  f"薪资：{salary}")
         else:
            print("该工号不存在！")

   elif order == 2:
         job = input("职位（E.普通员工；T.组长；M.经理）：")
         job = super().check(job)
         job, job_cn = super().shift_en(job), super().shift_cn(job)
         if self.job:
            print(f"目前{job_cn}共有{len(self.job)}人：")
            for i in self.job:
               print(f"{i} - {self.job}")
         else:
            print(f"目前公司没有{job_cn}")

def upgrade(self):
   uid = int(input("请输入工号："))
   if uid in self.members:
         play = self.members
         salary = play.salary()
         print(f"{play.name}，工号：{uid}，当前职位：{play.job}{play.grade}，当前薪资：{salary}")

         up = int(input("请输入需要增加的级数："))
         print("升级成功")
         grade = play.grade + up
         job, grade = super().up_down(play.job, grade)
         if play.job != job:
            del self.job
            self.job = play.name
            play.job = job
         play.job = job
         play.grade = grade
         new_salary = play.salary()
         print(f"{play.name}，工号：{uid}，升级后职位：{job}{play.grade}，升级后薪资：{new_salary}(+{new_salary - salary})")
   else:
         print("该工号不存在！")

def relegation(self):
   uid = int(input("请输入工号："))
   if uid in self.members:
         play = self.members
         salary = play.salary()
         print(f"{play.name}，工号：{uid}，当前职位：{play.grade}，当前薪资：{salary}")

         down = int(input("请输入需要增加的级数："))
         print("升级成功")
         grade = play.grade - down
         job, grade = super().up_down(play.job, grade)
         if play.job != job:
            del self.job
            self.job = play.name
            play.job = job
         play.grade = grade
         new_salary = play.salary()
         print(f"{play.name}，工号：{uid}，降级后职位：{job}{play.grade}，降级后薪资：{new_salary}({new_salary - salary})")
   else:
         print("该工号不存在！")

# 执行
main = Manage()
while True:
try:
   o = int(input("1.录入;2.查询;3.升级;4.降级;5.退出："))
   if o == 1:
         main.register()
   elif o == 2:
         main.inquire()
   elif o == 3:
         main.upgrade()
   elif o == 4:
         main.relegation()
   elif o == 5:
         break
except ValueError:
   print("请输入正确的指令！")

wzy19990605 发表于 2023-2-19 10:26:52

Cun_ 发表于 2023-2-18 17:54:10

{:5_101:}

JesseGu 发表于 2023-2-18 15:11:40

问答题：

0.

1.根据不同的对象进行不同的操作

2.可以

3.

4.

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

鱼C论坛's Archiver