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

A_KUN 发表于 2024-6-11 16:29:54

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

第 4 题的答案是：

第 5 题的答案是：

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

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

小白不急躁 发表于 2024-6-10 12:21:40

请回复您的答案^_^

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

第 0 题的答案是：
多态本来就是Pyhton本身自身的特性
第 1 题的答案是：
能让函数接收不同的对象作为参数，并且不检查其类型的情况下去执行它的方法
第 2 题的答案是：
可以称之为多态；第一个是整数相关的，第二个是str相关的
python很是顺气自然的执行了
第 3 题的答案是：
那么这个对象即有鸭子的属性又有鸭子的方法
那么这个对象就是鸭子
第 4 题的答案是：
应该是和耦合度有关系降低了耦合度
第 5 题的答案是：
是
-------- 动动手 --------

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

Moiy 发表于 2024-6-5 14:41:01

程同学295 发表于 2024-6-1 18:58:58

请回复您的答案^_^

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

第 0 题的答案是：
只要调用的函数在类中有定义，无论是否同类，都不会报错
第 1 题的答案是：
一鱼多吃
第 2 题的答案是：
不行
第 3 题的答案是：

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

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

ajaklfkadfj 发表于 2024-5-31 21:27:42

延陵呆子 发表于 2024-5-31 13:11:32

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

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

class Member:
def __init__(self):
   self.get_name()
   self.get_job()
   self.get_year()
   self.get_grade()
def get_uid(self):
   self.uid = None
def get_name(self):
   name = input("姓名：")
   self.name = name
def get_job(self):
   job = input("职位（E.普通员工;T.组长;M.经理）：")
   self.job = job
def get_grade(self):
   grade = input("级别：")
   panduan = 0
   while panduan == 0:
         if (self.job == 'M') and (int(grade) > 3):
            grade = input("该职位最高级别为3，请重新录入级别：")
         elif (self.job == 'T') and (int(grade) > 6):
            grade = input("该职位最高级别为6，请重新录入级别：")
         elif (self.job == 'E') and (int(grade) > 10):
            grade = input("该职位最高级别为10，请重新录入级别：")
         else:
            panduan = 1
   self.grade = int(grade)
def get_year(self):
   self.year = int(input("工龄："))


class Mixin:
def grade_up(self,job,gradenow):
   num = int(input("请输入需要增加的级别数："))
   if job == 'M':
         if gradenow + num <= 3:
            grade = gradenow +num
         else:
            grade = 3
         job = 'M'
   elif job == 'T':
         if gradenow +num <= 6:
            job = 'T'
            grade = gradenow +num
         else:
            job = 'M'
            grade = 1
   elif job == 'E':
         if gradenow +num <= 10:
            job = 'E'
            grade = gradenow +num
         else:
            job = 'T'
            grade = 1
   return (job, grade)
def grade_low(self,job,gradenow):
   num = int(input("请输入需要减少的级别数："))
   if job == 'M':
         if gradenow - num <= 0:
            job = 'T'
            grade = 6
         else:
            grade = gradenow - num
   elif job == 'T':
         if gradenow -num <= 0:
            job = 'E'
            grade = 10
         else:
            job = 'T'
            grade = gradenow - num
   elif job == 'E':
         if gradenow -num <= 0:
            job = 'E'
            grade = 1
         else:
            job = 'E'
            grade = gradenow - num
   return (job, grade)

class Manage(Mixin):
def __init__(self):
   self.members = {}
   self.cardid = 10000
def welcome(self):
   while True:
         print("\n")
         ins = input("1.录入;2.查询;3.升级;4.降级;5.退出：")
         if ins == '1':
            self.creat_member()
         if ins == '2':
            self.view()
         if ins == '3':
            self.gradeup()
         if ins == '4':
            self.gradelow()
         if ins == '5':
            break



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

def creat_member(self):
   member = Member()
   member.uid = self.cardid
   member.salary = self.salary(member.job,member.grade,member.year)
   self.members = member
   self.cardid += 1
   print(f"录入成功！姓名：{member.name}，工号：{member.uid}，薪资：{member.salary}")
def view(self):
   choose = input("1.员工查询；2.职位查询：")
   if choose == '1':
         uid = int(input("请输入工号："))
         if not self.members.get(uid):
            print("该工号不存在：")
         else:
            member = self.members.get(uid)
            print(f"姓名：{member.name}")
            print(f"职位：{member.job}")
            print(f"级别：{member.grade}")
            print(f"工龄:{member.year}")
            print(f"薪资：{member.salary}")
   if choose == '2':
         s = 0
         jihe = []
         job = input("职位（E.普通员工;T.组长;M.经理）：")
         for each in self.members:
            member = self.members.get(each)
            if member.job == job:
               s += 1
               jihe.append()
         if job == 'E':
            print(f"目前普通员工有{s}人")
         if job == 'T':
            print(f"目前组长有{s}人")
         if job == 'M':
            print(f"目前经理有{s}人")
         for each in jihe:
            print(f'{each} - {each}')

def gradeup(self):
   uid = int(input("请输入工号："))
   member = self.members.get(uid)
   qianxz = member.salary
   print(f"姓名：{member.name}，工号：{member.uid}，当前职位：{member.job}{member.grade}，当前薪资：{qianxz}")
   member.job, member.grade = self.grade_up(member.job,member.grade)
   member.salary = self.salary(member.job,member.grade,member.year)
   zengjia = member.salary-qianxz
   print("升级成功！")
   print(f"姓名：{member.name}，工号：{member.uid}，升级后职位：{member.job}{member.grade}，升级后薪资：{member.salary}(+{zengjia})")
def gradelow(self):
   uid = int(input("请输入工号："))
   member = self.members.get(uid)
   qianxz = member.salary
   print(f"姓名：{member.name}，工号：{member.uid}，当前职位：{member.job}{member.grade}，当前薪资：{qianxz}")
   member.job, member.grade = self.grade_low(member.job,member.grade)
   member.salary = self.salary(member.job,member.grade,member.year)
   jianshao = member.salary-qianxz
   print("降级成功！")
   print(f"姓名：{member.name}，工号：{member.uid}，降级后职位：{member.job}{member.grade}，降级后薪资：{member.salary}({jianshao})")

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

cc958 发表于 2024-5-31 10:30:00

延陵呆子 发表于 2024-5-30 16:46:50

0.
子类对父类的重写
函数的鸭子类型

1.
可以被反复调用，节约空间

2.
可以

3.
不知道

4.
增强了内度
提高了耦合

5.
不是

meimei003851 发表于 2024-5-28 16:15:02

请回复您的答案^_^

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

第 0 题的答案是：

第 1 题的答案是：

第 2 题的答案是：

第 3 题的答案是：

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

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

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

FishLiu 发表于 2024-5-28 15:37:15

本帖最后由 FishLiu 于 2024-5-28 23:15 编辑

请回复您的答案^_^

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

第 0 题的答案是：同一个运算符、函数或对象在不同的场景下，具有不同的作用效果。

第 1 题的答案是：尽管我们的接口是不变的，但它却可以根据不同的对象执行不同的操作。

第 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 set_grade(self, grade):
   self.grade = grade

def get_year(self):
   return self.year

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)

def main():
employee = {}
jobs = {'E': [], 'T': [], 'M': []}
uid = 10000
max_e = 10
max_t = 6
max_m = 3

while True:
   ins = input("\n1.录入；2.查询；3.升级；4.降级；5.退出：")
   if ins == '1':
         name = input("姓名：")
         job = input("职位（E.普通员工；T.组长；M.经理）：")
         year = int(input("工龄："))
         grade = int(input("级别："))
         if job == "E":
            while grade > max_e:
               grade = int(input(f"该职位最高级别为{max_e}，请重新录入级别："))

            e = Employee(uid, name, job, grade, year)
            employee = e
            jobs['E'].append(e)
         if job == "T":
            while grade > max_t:
               grade = int(input(f"该职位最高级别为{max_t}，请重新录入级别："))

            e = Teamleader(uid, name, job, grade, year)
            employee = e
            jobs['T'].append(e)
         if job == "M":
            while grade > max_m:
               grade = int(input(f"该职位最高级别为{max_m}，请重新录入级别："))

            e = Manager(uid, name, job, grade, year)
            employee = e
            jobs['M'].append(e)

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

   if ins == '2':
         finder = input("1.员工查询；2.职位查询：")
         if finder == '1':
            find_uid = int(input("请输入工号："))
            if employee.get(find_uid):
               e = employee
               print(f"姓名：{e.get_name()}", f"职位：{e.get_job()}", f"级别：{e.get_grade()}",
                     f"工龄：{e.get_year()}",
                     f"薪资：{e.salary()}", sep="\n")
            else:
               print("该工号不存在！")
         if finder == '2':
            find_job = input("请输入职位（E.普通员工；T.组长；M.经理）：")
            if find_job == 'E':
               if jobs['E']:
                     print(f"目前普通员工共有{len(jobs['E'])}人：")
                     for each in jobs['E']:
                        print(f"{each.get_uid()} - {each.get_name()}")
               else:
                     print("该公司目前没有普通员工！")
            if find_job == 'T':
               if jobs['T']:
                     print(f"目前普通员工共有{len(jobs['T'])}人：")
                     for each in jobs['T']:
                        print(f"{each.get_uid()} - {each.get_name()}")
               else:
                     print("该公司目前没有组长！")
            if find_job == 'M':
               if jobs['M']:
                     print(f"目前普通员工共有{len(jobs['M'])}人：")
                     for each in jobs['M']:
                        print(f"{each.get_uid()} - {each.get_name()}")
               else:
                     print("该公司目前没有经理！")
   if ins == '3':
         up_uid = int(input("请输入工号："))
         if employee.get(up_uid):
            e = employee
            uid = e.get_uid()
            name = e.get_name()
            job = e.get_job()
            grade = e.get_grade()
            year = e.get_year()
            old_salary = e.salary()
            print(f"{name}，工号：{uid}，当前职位：{job}{grade}，当前薪资：{old_salary}")
            n = int(input("请输入需要增加的级数："))

            if job == 'E':
               if grade + n > max_e:
                     job = 'T'
                     grade = 1
                     jobs['E'].remove(e)
                     e = Teamleader(uid, name, job, grade, year)
                     jobs['T'].append(e)
                     employee = e
               else:
                     e.set_grade(grade + n)
            elif job == 'T':
               if grade + n > max_t:
                     job = 'M'
                     grade = 1
                     jobs['T'].remove(e)
                     e = Manager(uid, name, job, grade, year)
                     jobs['M'].append(e)
                     employee = e
               else:
                     e.set_grade(grade + n)
            elif job == 'M':
               if grade + n > max_m:
                     print("已达到最高级别！")
                     e.set_grade(max_m)
               else:
                     e.set_grade(grade + n)

            new_salary = e.salary()
            print("升级成功！")
            print(
               f"{e.get_name()}，工号：{e.get_uid()}，升级后职位{e.get_job()}{e.get_grade()}，升级后薪资{new_salary}(+{new_salary - old_salary})")
         else:
            print("工号不存在！")

   if ins == '4':
         up_uid = int(input("请输入工号："))
         if employee.get(up_uid):
            e = employee
            uid = e.get_uid()
            name = e.get_name()
            job = e.get_job()
            grade = e.get_grade()
            year = e.get_year()
            old_salary = e.salary()
            print(f"{name}，工号：{uid}，当前职位：{job}{grade}，当前薪资：{old_salary}")
            n = int(input("请输入需要减少的级数："))

            if job == 'E':
               if grade - n < 1:
                     print("已达到最低级别！")
                     e.set_grade(1)
               else:
                     e.set_grade(grade - n)
            elif job == 'T':
               if grade - n < 1:
                     job = 'E'
                     grade = max_e
                     jobs['T'].remove(e)
                     e = Employee(uid, name, job, grade, year)
                     jobs['E'].append(e)
                     employee = e
               else:
                     e.set_grade(grade - n)
            elif job == 'M':
               if grade - n < 1:
                     job = 'T'
                     grade = max_t
                     jobs['M'].remove(e)
                     e = Teamleader(uid, name, job, grade, year)
                     jobs['T'].append(e)
                     employee = e
               else:
                     e.set_grade(grade - n)

            new_salary = e.salary()
            print("升级成功！")
            print(
               f"{e.get_name()}，工号：{e.get_uid()}，升级后职位{e.get_job()}{e.get_grade()}，升级后薪资{new_salary}(-{new_salary - old_salary})")
         else:
            print("工号不存在！")

   if ins == '5':
         break

噩梦症候群 发表于 2024-5-27 21:44:31

问答题：
0.
重写类的方法
1.
灵活，不用关注对象的类型，根据对象的不同情况输出响应的内容
2.
得到的结果是相同的啊，我觉得可以成为多态
3.
不知道
4.
增强了内聚
5.
不属于

动动手：
0.

miaozai122 发表于 2024-5-21 19:04:32

请回复您的答案^_^

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

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

pyzzx 发表于 2024-5-18 14:54:23

15278363968 发表于 2024-5-17 09:51:46

格子penbeat 发表于 2024-5-16 11:06:19

suaiguo007 发表于 2024-5-14 15:55:31

#0 企业员工管理程序

# 会员类：记录会员的关键信息
class Member:
def __init__(self, uid, name, job, grade, year, salary ): #设置构造函数，
   self.uid = uid
   self.name = name
   self.job = job
   self.grade = grade
   self.year = year
   self.salary = salary

# 管理类：所有功能的实现
class Manage:
def __init__(self):
   self.members = {} #初始化self.members是一个空字典，用来存储{uid:Member}
   self.uid = 10000 #初始化self.uid 起始10000

#确认工号，后续功能需要先 check_uid
def check_uid(self):
   uid = int(input("请输入工号： "))
   while not self.members.get(uid):
         uid = int(input("该工号不存在! 请输入工号： "))
   return uid #直到输入正确工号，返回uid

#程序功能入口
def welcome(self):
   ins = 0
   print("欢迎使用会员管理系统")
   while ins != 5:
         ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出: ")
         if ins == "1":
            self.create_member()
         if ins == "2":
            self.search_member()
         if ins == "3":
            self.upgrade_member()
         if ins == "4":
            self.degrade_member()
         if ins == "5":
            print("感谢使用会员管理系统")
            break

#程序功能:创建人物
def create_member(self):
   name = input("姓名： ")
   job = input("职位(E.普通员工;T.组长;M.经理): ")
   while job != "E" and job != "T" and job != "M":       #确认E T M
         job = input("职位(E.普通员工;T.组长;M.经理): ")
   year = int(input("工龄: "))
   while year < 0:                                     #确认正整数工龄
         year = int(input("不能为负数，请输入工龄: "))
   grade = int(input("级别: "))
   while grade < 0:                                     #确认正整数级别
         grade = int(input("不能为负数，请输入级别: "))

   # 算salary
   salary = 0
   if job == "E":
         if 0 < grade <= 10:
            salary = 3000 + 500 * grade + 50 * year
         else:
            while grade <= 0 or grade > 10:
               grade = int(input("该职位最高级别为10，请重新录入级别: "))
               salary = 3000 + 500 * grade + 50 * year
   if job == "T":
         if 0 < grade <= 6:
            salary = 4000 + 800 * grade + 100 * year
         else:
            while grade <= 0 or grade > 6:
               grade = int(input("该职位最高级别为6，请重新录入级别: "))
               salary = 4000 + 800 * grade + 100 * year
   if job == "M":
         if 0 < grade <= 3:
            salary = 5000 + 1000 * (grade + year)
         else:
            while grade <= 0 or grade > 3:
               grade = int(input("该职位最高级别为3，请重新录入级别: "))
               salary = 5000 + 1000 * (grade + year)
   member = Member(self.uid, name, job, grade, year, salary)
   self.members = member
   print(f"录入成功！姓名: {name}, 工号: {self.uid}, 薪资： {salary}")
   print(self.members)
   self.uid += 1

#程序功能:查询人物
def search_member(self):
   ins = 0

   while ins != "5":
         ins = input("\n1.工号查询;2.职位查询;5.退出: ")

         if ins == "1":
            self.find_uid()
         if ins == "2":
            self.check_job()
         if ins =="5":
            print("已返回上级菜单")
            break


#程序功能:查询人物-工号查询
def find_uid(self):
   uid = self.check_uid()
   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}")

#程序功能:查询人物-职位查询
def check_job(self):
   jobtitle = {"E":"普通员工", "T":"组长", "M":"经理"} #利用字典的键值对
   ckjob = input("职位(E.普通员工;T.组长;M.经理): ")
   jobnum = 0          #此job中的数量
   jobuid = []          #此job中id列表
   jobname = []          #此job中name列表
   for i in self.members:
         if self.members.job == ckjob:          #遍历self.members列表的下标号，if == ckjob 需查询的job
            jobnum += 1                         #此job中的数量
            jobuid.append(self.members.uid)    #此job中id列表
            jobname.append(self.members.name) #此job中name列表
   if jobnum == 0:
         print(f"目前公司没有{jobtitle}!!!") #利用字典的键值对
   else:
         print(f"目前{jobtitle}共有{len(jobuid)}人： ") #利用字典的键值对, len此job的id数量
         for j in range(len(jobuid)):             #遍历此job中id列表的下标号
            print(jobuid,"-",jobname)       #打印对应下标号的id - name

#程序功能:升级
def upgrade_member(self):
   uid = self.check_uid()
   print(f"{self.members.name},工号:{uid} , 当前职位:{self.members.job}{self.members.grade} , 当前薪资: {self.members.salary}")
   oldsalary = self.members.salary
   upnum = int(input("请输入需要增加的级数: "))
   while upnum < 0:
         upnum = int(input("不能为负数，请输入需要增加的级数: "))    #确认输入正整数
   newgrade = self.members.grade + upnum
   # E升级
   if self.members.job == "E":
         if newgrade > 0 and newgrade <= 10:
            self.members.grade = newgrade
            self.members.salary = 3000 + 500 * self.members.grade + 50 * self.members.year
         else:
            self.members.grade = 1
            self.members.job = "T"
            self.members.salary = 4000 + 800 * self.members.grade + 100 * self.members.year
         print("升级成功")
         print(f"{self.members.name},工号:{uid} , 当前职位:{self.members.job}{self.members.grade} , 当前薪资: {self.members.salary}(+{(self.members.salary - oldsalary)})")

   # T升级
   if self.members.job == "T":
         if newgrade > 0 and newgrade <= 6:
            self.members.grade = newgrade
            self.members.salary = 4000 + 800 * self.members.grade + 100 * self.members.year
         else:
            self.members.grade = 1
            self.members.job = "M"
            self.members.salary = 5000 + 1000 * (self.members.grade + self.members.year)
         print("升级成功")
         print(f"{self.members.name},工号:{uid} , 当前职位:{self.members.job}{self.members.grade} , 当前薪资: {self.members.salary}(+{self.members.salary - oldsalary})")

   # M升级
   if self.members.job == "M":
         if newgrade > 0 and newgrade <= 3:
            self.members.grade = newgrade
            self.members.salary = 5000 + 1000 * (self.members.grade + self.members.year)
            print("升级成功")
         else:
            print("要洗块垒，农药琦当老板咯")



#程序功能:降级
def degrade_member(self):
   uid = self.check_uid()
   print(f"{self.members.name},工号:{uid} , 当前职位:{self.members.job}{self.members.grade} , 当前薪资: {self.members.salary}")
   oldsalary = self.members.salary
   upnum = int(input("请输入需要减少的级数: "))
   while upnum < 0:
         upnum = int(input("不能为负数，请输入需要减少的级数: "))    #确认输入正整数
   newgrade = self.members.grade - upnum

   # E降级
   if self.members.job == "E":
         if newgrade > 0 and newgrade <= 10:
            self.members.grade = newgrade
            self.members.salary = 3000 + 500 * self.members.grade + 50 * self.members.year
            print("降级成功")
         else:
            print("降过最低数，要炒鱿鱼啦~")
         print(f"{self.members.name},工号:{uid} , 当前职位:{self.members.job}{self.members.grade} , 当前薪资: {self.members.salary}({(self.members.salary - oldsalary)})")

   # T降级
   if self.members.job == "T":
         if newgrade > 0 and newgrade <= 6:
            self.members.grade = newgrade
            self.members.salary = 4000 + 800 * self.members.grade + 100 * self.members.year
         else:
            self.members.grade = 10
            self.members.job = "E"
            self.members.salary = 3000 + 500 * self.members.grade + 50 * self.members.year
         print("降级成功")
         print(f"{self.members.name},工号:{uid} , 当前职位:{self.members.job}{self.members.grade} , 当前薪资: {self.members.salary}({(self.members.salary - oldsalary)})")

   # M降级
   if self.members.job == "M":
         if newgrade > 0 and newgrade <= 3:
            self.members.grade = newgrade
            self.members.salary = 5000 + 1000 * (self.members.grade + self.members.year)
         else:
            self.members.grade = 6
            self.members.job = "T"
            self.members.salary = 4000 + 800 * self.members.grade + 100 * self.members.year
         print("降级成功")
         print(f"{self.members.name},工号:{uid} , 当前职位:{self.members.job}{self.members.grade} , 当前薪资: {self.members.salary}({(self.members.salary - oldsalary)})")




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


打卡

mzlhandsome 发表于 2024-5-13 16:29:50

看一下

pythonier 发表于 2024-5-5 20:24:05

15135710508 发表于 2024-5-3 08:49:05

答案见附件

kfc2012008 发表于 2024-5-2 10:44:07

本帖最后由 kfc2012008 于 2024-5-2 16:41 编辑

请回复您的答案^_^

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

第 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 Members:
def __init__(self,name,job,year,uld,grade):
   self.name = name
   self.job= job
   self.year = year
   self.uld= uld
   self.grade = grade
   self.x = 0
   self.y = 0
   self.z = 0
def get_uid(self):
   return self.uld
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 self.x+self.y*self.grade+self.z*self.year
class Employee(Members):
def __init__(self,name,job,year,uld,grade):
      Members.__init__(self,name,job,year,uld,grade)
      self.x = 3000
      self.y = 500
      self.z = 50
class Teamleader(Members):
def __init__(self,name,job,year,uld,grade):
      Members.__init__(self,name,job,year,uld,grade)
      self.x = 4000
      self.y = 800
      self.z = 100
class Manager(Members):
def __init__(self,name,job,year,uld,grade):
      Members.__init__(self,name,job,year,uld,grade)
      self.x = 5000
      self.y = 1000
      self.z = 1000
class Manage:
def__init__(self):
   self.uld = 10000
   self.members = {}
   self.Employee = {}
   self.Teamleader ={}
   self.Manager = {}
def c_grade(self,job,grade):
   if job == "E":
         while True:
            if grade <= 10:
                  return grade
            else:
                  grade =int(input("该职位最高级别为10，请重新录入级别："))

   elif job == "T":
         while True:
            if grade <= 6:
                  return grade
            else:
                  grade =int(input("该职位最高级别为6，请重新录入级别："))

   elif job == "M":
         while True:
            if grade <= 3:
                  return grade
            else:
                  grade =int(input("该职位最高级别为3，请重新录入级别："))

def c_job(self,name,job,year,uld,grade):
   if job == "E":
         return Employee(name,job,year,uld,grade)

   elif job == "T":
         return Teamleader(name,job,year,uld,grade)

   elif job == "M":
         return Manager(name,job,year,uld,grade)

defm_1(self):
   while True:
      n = input("\n1.录入;2.查询;3.升级;4.降级;5.退出:")
      if n == "1":
         self.in_p()
      elif n == "2":
         self.c_x()
      elif n == "3":
         self.up_job()
      elif n == "4":
         self.down_job()
      elif n == '5':
         break
def in_p(self):
   name = input("姓名：")
   job = input("职位(E.普通员工;T.组长;M.经理):")
   year = int(input("工龄："))
   grade = int(input("级别："))
   grade = self.c_grade(job,grade)
   members_1 = self.c_job(name,job,year,self.uld,grade)
   self.members = members_1
   salary = members_1.salary()
   print(f"录入成功！姓名：{name},工号：{self.uld}，薪资：{salary}")
   self.uld = self.uld + 1
def ex_job(self,x):#转换名称
   if x == "E":
         return "普通员工"
   elif x == "T":
         return "组长"
   elif x == "M":
         return "经理"
def c_x(self):
   n = input("1.员工查询；2.职位查询")
   if n == "1":
         uld = int(input("请输入工号"))
         if self.members.get(uld):
            print(f"姓名：{self.members.name}\n职位：{self.members.job}\n级别：{self.members.grade}\n薪资：{self.members.salary()}")

         else:
            print("该工号不存在")
   elif n == "2":
         job = input("职位(E.普通员工;T.组长;M.经理):")
         n = 0
         list_1 = []
         for each in self.members:
            if self.members.job == job:
                  n = n + 1
                  list_1.append(f"{self.members.uld} - {self.members.name}")

         if n == 0:
            print(f"目前公司没有{self.ex_job(job)}")
         else:
            print(f"目前共有{self.ex_job(job)}{n}人。")
            for each in list_1:
               print(each)
def up_job(self):
   uld = int(input("请输入工号："))
   ifself.members.get(uld):
         print(f"{self.members.name},工号：{uld}，当前职位：{self.members.job}{self.members.grade},薪资：{self.members.salary()}")
         ex_grade = int(input("请输入增加级数："))
         old_pay = self.members.salary()
         new_grade = self.members.grade + ex_grade
         if self.members.job == "E":
               if new_grade <= 10:
                  self.members.grade =new_grade
               else:
                     self.members = Teamleader(self.members.name,"T",self.members.year,uld,1)

         elif self.members.job == "T":
               if new_grade <= 6:
                     self.members.grade =new_grade
               else:
                     self.members = Manager(self.members.name,"M",self.members.year,uld,1)

         elif self.members.job == "M":
               if new_grade <= 3:
                  self.members.grade =new_grade
               else:
                     self.members.grade =3
                     print("已达最高")
         new_pay = self.members.salary()
         change_pay =new_pay - old_pay
         print("升级成功！")
         print(f"{self.members.name},工号：{uld}，当前职位：{self.members.job}{self.members.grade},升级后薪资：{self.members.salary()}(+{change_pay})")

def down_job(self):
      uld = int(input("请输入工号："))
      ifself.members.get(uld):
         print(f"{self.members.name},工号：{uld}，当前职位：{self.members.job}{self.members.grade},薪资：{self.members.salary()}")
         ex_grade = int(input("请输入减少级数："))
         old_pay = self.members.salary()
         new_grade = self.members.grade - ex_grade
         if self.members.job == "E":
               if new_grade >= 1:
                  self.members.grade =new_grade
               else:
                     print("已达最低")
                     self.members.grade =1

         elif self.members.job == "T":
               if new_grade >= 1:
                  self.members.grade =new_grade
               else:
                     self.members = Employee(self.members.name,"E",self.members.year,uld,10)

         elif self.members.job == "M":
               if new_grade >= 1 :
                  self.members.grade =new_grade
               else:
                     self.members = Teamleader(self.members.name,"T",self.members.year,uld,6)
         new_pay = self.members.salary()
         change_pay = old_pay - new_pay
         print("降级级成功！")
         print(f"{self.members.name},工号：{uld}，当前职位：{self.members.job}{self.members.grade},降级后薪资：{self.members.salary()}(-{change_pay})")

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

main()

页: 12 13 14 15 16 17 18 19 20 21 [22] 23 24 25 26 27 28 29 30 31

鱼C论坛's Archiver