请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：nb
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
看看~~~~~~~~~~~~~~~~
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------1
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：同一个运算符、函数或对象在不同的场景下有不同的作用
第 1 题的答案是：可以应用于不同的场景
第 2 题的答案是：可以
第 3 题的答案是：一个鸟，走起来像鸭子，游起泳来像鸭子，叫起来也像鸭子，那么这个鸟就可以称之为鸭子。
第 4 题的答案是：低耦合
第 5 题的答案是：是
-------- 动动手 --------
请将第 0 题的代码写在下方：
class Arbeiter:
def __init__(self, name, job, grade, year, uid, salary):
self.name = name
self.job = job
self.grade = grade
self.year = year
self.uid = uid
self.salary = salary
def get_uid(self, serial):
uid = serial
return uid
def get_name(self):
name = input("姓名：")
return name
def get_job(self):
job = input("职位（E.普通员工；T.组长；M.经理）：")
while True:
if job == 'E' or job == 'T' or job == 'M':
break
else:
job = input("该职位不存在，请重新输入（E.普通员工；T.组长；M.经理）：")
return job
def get_grade(self, job):
grade = int(input("级别："))
if job == 'E':
stufe = EmployeeMaxin.set_grade(self, grade)
if job == 'T':
stufe = TeamleaderMaxin.set_grade(self, grade)
if job == 'M':
stufe = ManagerMaxin.set_grade(self, grade)
return stufe
def get_year(self):
year = int(input("工龄："))
while year < 0:
year = int(input("输入错误，请重新输入工龄："))
return year
def get_salary(self, job, grade, year):
if job == 'E':
salary = EmployeeMaxin.salary(self, grade, year)
if job == 'T':
salary = TeamleaderMaxin.salary(self, grade, year)
if job == 'M':
salary = ManagerMaxin.salary(self, grade, year)
return salary
class EmployeeMaxin:
def set_grade(self, grade, grenze = 10):
while grade > grenze:
grade = int(input(f"该职位最高级别为{grenze}，请重新录入级别："))
return grade
def salary(self, grade, year):
lohn = 3000 + 500 * grade + 50 * year
return lohn
class TeamleaderMaxin:
def set_grade(self, grade, grenze = 6):
while grade > grenze:
grade = int(input(f"该职位最高级别为{grenze}，请重新录入级别："))
return grade
def salary(self, grade, year):
lohn = 4000 + 800 * grade + 100 * year
return lohn
class ManagerMaxin:
def set_grade(self, grade, grenze = 3):
while grade > grenze:
grade = int(input(f"该职位最高级别为{grenze}，请重新录入级别："))
return grade
def salary(self, grade, year):
lohn = 5000 + 1000 * (grade + year)
return lohn
class Management(Arbeiter, EmployeeMaxin, TeamleaderMaxin, ManagerMaxin):
def __init__(self):
self.members = {}
self.serial = 10000
def eingeben(self):
name = self.get_name()
job = self.get_job()
year = self.get_year()
grade = self.get_grade(job)
salary = self.get_salary(job, grade, year)
uid = self.get_uid(self.serial)
arbeiter = Arbeiter(name, job, grade, year, uid, salary)
self.members = arbeiter
self.serial += 1
print(f"录入成功！姓名：{name}，工号：{uid}，薪资：{salary}")
def suchen(self):
n = input("1.员工查询；2.职位查询：")
while n != '1' and n != '2':
n = input("指令错误，请重新输入（1.员工查询；2.职位查询）：")
if n == '1':
UID = int(input("请输入工号："))
if UID in self.members:
arbeiter = self.members
print(f"姓名：{arbeiter.name}")
print(f"职位：{arbeiter.job}")
print(f"级别：{arbeiter.grade}")
print(f"工龄：{arbeiter.year}")
print(f"薪资：{arbeiter.salary}")
else:
print("该工号不存在！")
if n == '2':
j = input("职位（E.普通员工；T.组长；M.经理）：")
while True:
if j == 'E':
i = 0
M = []
for each in self.members.values():
if each.job == 'E':
i += 1
M.append(each)
if i > 0:
print(f"目前普通员工共有 {i} 人：")
for jede in M:
print(f"{jede.uid} - {jede.name}")
else:
print("目前公司没有普通员工！")
break
if j == 'T':
i = 0
M = []
for each in self.members.values():
if each.job == 'T':
i += 1
M.append(each)
if i > 0:
print(f"目前组长共有 {i} 人：")
for jede in M:
print(f"{jede.uid} - {jede.name}")
else:
print("目前公司没有组长！")
break
if j == 'M':
i = 0
M = []
for each in self.members.values():
if each.job == 'M':
i += 1
M.append(each)
if i > 0:
print(f"目前经理共有 {i} 人：")
for jede in M:
print(f"{jede.uid} - {jede.name}")
else:
print("目前公司没有经理！")
break
else:
j = input("指令错误，请重新输入（E.普通员工；T.组长；M.经理）：")
def upgrade(self):
UID = int(input("请输入工号："))
while UID not in self.members:
UID = int(input("该工号不存在，请输入工号："))
arbeiter = self.members
print(f"{arbeiter.name}，工号{arbeiter.uid}，当前职位{arbeiter.job}{arbeiter.grade}，当前薪资：{arbeiter.salary}")
level = int(input("请输入需要增加的级数："))
new_grade = arbeiter.grade + level
while True:
if arbeiter.job == 'E' and new_grade > 10:
arbeiter.job = 'T'
arbeiter.grade = 1
break
if arbeiter.job == 'T' and new_grade > 6:
arbeiter.job = 'M'
arbeiter.grade = 1
break
else:
arbeiter.grade = new_grade
break
old_salary = arbeiter.salary
new_salary = self.get_salary(arbeiter.job, arbeiter.grade, arbeiter.year)
arbeiter.salary = new_salary
print("升级成功！")
diff = new_salary - old_salary
if diff >= 0:
print(f"{arbeiter.name}，工号：{arbeiter.uid}，升级后职位：{arbeiter.job}{arbeiter.grade}，升级后薪资：{arbeiter.salary}(+{diff})")
if diff < 0:
print(f"{arbeiter.name}，工号：{arbeiter.uid}，升级后职位：{arbeiter.job}{arbeiter.grade}，升级后薪资：{arbeiter.salary}({diff})")
def degrade(self):
UID = int(input("请输入工号："))
while UID not in self.members:
UID = int(input("该工号不存在，请输入工号："))
arbeiter = self.members
print(f"{arbeiter.name}，工号：{arbeiter.uid}，当前职位：{arbeiter.job}{arbeiter.grade}，当前薪资：{arbeiter.salary}")
level = int(input("请输入需要减少的级数："))
new_grade = arbeiter.grade - level
while True:
if arbeiter.job == 'M' and new_grade < 1:
arbeiter.job = 'T'
arbeiter.grade = 6
break
if arbeiter.job == 'T' and new_grade < 1:
arbeiter.job = 'E'
arbeiter.grade = 10
break
else:
arbeiter.grade = new_grade
break
old_salary = arbeiter.salary
new_salary = self.get_salary(arbeiter.job, arbeiter.grade, arbeiter.year)
arbeiter.salary = new_salary
print("降级成功！")
diff = new_salary - old_salary
if diff >= 0:
print(f"{arbeiter.name}，工号：{arbeiter.uid}，降级后职位：{arbeiter.job}{arbeiter.grade}，降级后薪资：{arbeiter.salary}(+{diff})")
if diff < 0:
print(f"{arbeiter.name}，工号：{arbeiter.uid}，降级后职位：{arbeiter.job}{arbeiter.grade}，降级后薪资：{arbeiter.salary}({diff})")
def main():
m = Management()
while True:
order = input("1.录入；2.查询；3.升级；4.降级；5.退出：")
while order not in ['1', '2', '3', '4', '5']:
order = input("指令错误，请重新输入。1.录入；2.查询；3.升级；4.降级；5.退出：")
if order == '1':
m.eingeben()
continue
if order == '2':
m.suchen()
continue
if order == '3':
m.upgrade()
continue
if order == '4':
m.degrade()
continue
if order == '5':
break
return
1
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^ds
-------- 问答题 --------
d
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
jiu 请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：1
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
谢谢分享
daka
请回复您的答案^_^
>>>>> 问答题 <<<<<
第 0 题的答案是：
在Python中，多态是面向对象编程的重要特性之一，它允许不同类的对象对同一个方法作出不同的响应。Python实现多态的方式主要依赖于动态类型特性和鸭子类型（duck typing）。
动态类型特性：Python是一种动态类型语言，它在运行时确定对象的类型。因此，可以将不同类的对象传递给同一个函数或方法，并且它们会根据其自身的类型执行不同的操作。
鸭子类型：在Python中，重要的不是对象是什么类型，而是它能做什么。这就是所谓的“鸭子类型”，即“如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子”。这意味着一个对象的类型并不重要，只要它实现了特定方法，就可以在代码中被视为另一种类型。
第 1 题的答案是：
多态的优势在于它增强了代码的灵活性、可扩展性和可维护性，使得代码更加模块化和易于理解。以下是多态的一些主要优势：
1. 灵活性和适应性：多态允许使用相同的接口来处理不同类型的对象，从而使得代码更具灵活性和适应性。通过多态，可以根据需要动态地选择合适的方法实现，而无需修改现有的代码结构。
2. 代码重用：通过使用多态，可以将通用的方法定义在父类中，并在子类中实现具体的行为。这样可以避免在不同的类中重复编写相似的代码，提高了代码的重用性。
3. 解耦合：多态减少了对象之间的耦合度，使得类之间的关系更加松散。当一个对象的具体类型发生变化时，只需要调整其引用的对象类型，而不需要修改与之相关的代码，从而降低了代码的维护成本。
4. 扩展性：通过继承和多态，可以轻松地扩展现有的代码功能，只需添加新的子类并实现相应的方法即可，而不需要修改已有的代码。
5. 抽象和封装：多态允许使用抽象的接口来操作对象，而无需了解对象的具体类型。这样可以隐藏对象的实现细节，提高了代码的封装性和安全性。
第 2 题的答案是：可以，加号的多态
第 3 题的答案是：有一只鸟，它看起来像鸭子，走起路来像鸭子，叫起来也像鸭子，那么这个鸟就是鸭子。
第 4 题的答案是：
使用鸭子类型通常有助于增强内聚并降低耦合度。
1.增强内聚：鸭子类型允许对象在运行时动态地决定其类型，而不依赖于显式的继承关系。这意味着在模块内部，对象的类型并不是硬编码的，而是根据其行为（即对象能够执行的方法）来确定。这种方式使得模块专注于处理对象的行为而不是特定的类型，从而增强了模块内的功能联系，提高了内聚度。
2.降低耦合度：鸭子类型通过关注对象的行为而不是具体的类型，降低了模块之间的耦合度。模块之间不再依赖于特定的类或接口，而是依赖于对象是否具有所需的方法。这意味着模块之间的连接更加灵活，不需要直接依赖于特定的类或接口，从而降低了模块之间的耦合度，提高了系统的灵活性和可维护性。
第 5 题的答案是：
这段代码展示了函数 add 的多态性，而不是 Python 中经典的面向对象编程中的多态。在函数 add 中，它可以接受两个或三个参数，并返回它们的和。在第一次调用中，只传递了两个参数，而在第二次调用中传递了三个参数。函数 add 能够根据传递的参数数量动态地调整自己的行为，这体现了函数的多态性。
Python 中的多态通常更与对象的行为相关，是面向对象编程的一个特性，可以通过方法的重载或继承来实现。在这个例子中，我们看到的是函数 add 在不同情况下的多态行为，而不是经典的基于继承和多态的面向对象编程中所谓的多态。
>>>>> 动动手 <<<<<
请将第 0 题的代码写在下方：
"""
请按要求编写一个企业员工管理程序。
需要实现的要求：
a. 员工分类：普通员工（Employee）、组长（Teamleader）、经理（Manager）
b. 员工属性：姓名（name）、职位（job）、级别（grade）、工龄（year）、工号（uid）
c. 员工方法：
get_uid() -- 获取工号
get_name() -- 获取姓名
get_job() -- 获取职位
get_grade() -- 获取级别
get_year() -- 获取工龄
salary() -- 统计并返回薪资（计算方法如下）
d. 员工薪资计算方法：
普通员工：3000 + 500 * 级别 + 50 * 工龄
组长：4000 + 800 * 级别 + 100 * 工龄
经理：5000 + 1000 * (级别 + 工龄)
e. 程序功能：
录入员工数据功能（工号自动分配，由 10000 开始）
查询功能，分为员工查询和职位查询（见程序实现截图）
各类员工级别数量如下：
普通员工：10 级
组长：6 级
经理：3 级
升级功能：支持增加多级；当超过当前职位最高级别时，进行升职操作（无论增加多少个级别，只要发生升职，级别一律初始化为 1 级，见程序实现截图）.
降级功能：支持减少多级；当超过当前职位最高级别时，进行升职操作（无论减少多少个级别，只要发生降职，级别一律初始化为当前职位最高级别，见程序实现截图）
录入功能实现如下：
1.录入；2.查询；3.升级；4.降级；5.退出：1
姓名：小甲鱼
职位（E.普通员工；T.组长；M.经理）：M
工龄：12
级别：3
录入成功！姓名：小甲鱼，工号：10000，薪资：20000
1.录入；2.查询；3.升级；4.降级；5.退出：1
姓名：不二如是
职位（E.普通员工；T.组长；M.经理）：T
工龄：10
级别：8
该职位最高级别为6，请重新录入级别：6
录入成功！姓名：不二如是，工号：10001，薪资：9800
1.录入；2.查询；3.升级；4.降级；5.退出：1
姓名：小师妹
职位（E.普通员工；T.组长；M.经理）：E
工龄：5
级别：5
录入成功！姓名：小师妹，工号：10002，薪资：5750
查询功能实现如下：
1.录入；2.查询；3.升级；4.降级；5.退出：2
1.员工查询；2.职工查询：1
请输入工号：10001
姓名：不二如是
职位：T
级别：6
工龄：10
薪资：9800
1.录入；2.查询；3.升级；4.降级；5.退出：2
1.员工查询；2.职工查询：1
请输入工号：10086
该工号不存在！
1.录入；2.查询；3.升级；4.降级；5.退出：2
1.员工查询；2.职工查询：2
职位（E.普通员工；T.组长；M.经理）：E
目前普通员工公有 1 人：
10002 - 小师妹
1.录入；2.查询；3.升级；4.降级；5.退出：2
1.员工查询；2.职工查询：2
职位（E.普通员工；T.组长；M.经理）：M
目前组长公有 1 人：
10000 - 小甲鱼
程序升降级功能实现如下：
1.录入；2.查询；3.升级；4.降级；5.退出：3
请输入工号：10001
不二如是，工号：10001，当前职位：T6，当前薪资：9800
请输入需要增加的级数：1
升级成功！
不二如是，工号：10001，升级后职位：M1，升级后薪资：16000（+6200）
1.录入；2.查询；3.升级；4.降级；5.退出：2
1.员工查询；2.职工查询：2
职位（E.普通员工；T.组长；M.经理）：T
目前公司没有组长！
1.录入；2.查询；3.升级；4.降级；5.退出：4
请输入工号：10001
不二如是，工号：10001，当前职位：M1，当前薪资：16000
请输入需要降低的级数：3
降级成功！
不二如是，工号：10001，降级后职位：T6，降级后薪资：9800（-6200）
1.录入；2.查询；3.升级；4.降级；5.退出：5
程序退出！
"""
class Employee_attribute:# 普通员工
def __init__(self, name, job, grade, year):
self.name = name# 姓名
self.job = job# 职位
self.grade = grade# 级别
self.year = year# 工龄
@staticmethod
def get_uid(number):# 输入员工号，返回用户名、用户职位和级别
return e.employee_dict.name, e.employee_dict.job, e.employee_dict.grade
@staticmethod
def get_name(number):# 根据工号获取姓名
return e.employee_dict.name
@staticmethod
def get_job(job_number):# 根据不同的输入获取职位
if job_number.isdecimal():# 如果输入的是员工编号
return e.employee_dict.job# 返回用户所属职位
elif job_number == 'E' or job_number == 'T' or job_number == 'M':# 如果用户输入职位
number = 0# 重复次数
result = []# 寻找到的员工号
job_title = ''# 职称
for k, v in e.employee_dict.items():
if v.job == job_number:
number += 1
result.append(k)
if job_number == 'E':
job_title = '普通员工'
elif job_number == 'T':
job_title = '组长'
elif job_number == 'M':
job_title = '经理'
print(f'目前{job_title}公有 {number} 人')
for i in result:
print(f'{i} - {e.employee_dict.name}')
print()
@staticmethod
def get_grade(number):# 根据工号获取级别
return e.employee_dict.grade
@staticmethod
def get_year(number):# 根据工号获取工龄
return e.employee_dict.year
@staticmethod
def salary(number):# 统计并返回薪资（计算方法如下）
"""
普通员工：3000 + 500 * 级别 + 50 * 工龄
组长：4000 + 800 * 级别 + 100 * 工龄
经理：5000 + 1000 * (级别 + 工龄)
"""
employee = e.employee_dict
grade = employee.grade
year = employee.year
job = employee.job
if job == 'E':# 普通员工
return 3000 + 500 * grade + 50 * year
elif job == 'T':# 组长
return 4000 + 800 * grade + 100 * year
elif job == 'M':# 经理
return 5000 + 1000 * (grade + year)
@staticmethod
def user_info(user_number):
user_data = Employee_attribute.get_uid(user_number)# 根据用户工号获取用户信息
salary = Employee_attribute.salary(user_number)
print(f'{user_data}，工号：{user_number}，当前职位：{user_data + str(user_data)}，当前薪资：{salary}')# 打印用户信息
return user_data, salary
class Employee:
def __init__(self):
self.employee_dict = {}# 员工数据
self.uid_number = '10000'# 员工编号
self.employee_level = [['E', 10], ['T', 6], ['M', 3]]# 职称数据
def employee_choice(self, choice):
if choice == '5':# 退出程序
print('程序退出！')
return True
# 录入员工
elif choice == '1':
input_name = input('姓名：')
# 判断用户输入姓名是否为空或已存在
while input_name == '':# 判断用户名是否为空
input_name = input('姓名不能为空，请重新输入：')
for k, v in e.employee_dict.items():# 迭代用户字典
while not v.name != input_name:# 如果名字重复则重新输入
input_name = input('用户名已被录入，请重新输入：')
# 允许用户输入小写字母并自动转换成大写，并规范用户输入
input_job = input('职位（E.普通员工；T.组长；M.经理）：').upper()# 将用户的输入切换成大写
while input_job not in ['E', 'T', 'M']:# 判断用户输入，如果不是指定输出则重新输入
input_job = input('请输入正确的字母，职位（E.普通员工；T.组长；M.经理）：').upper()
# 规范用户的输入为数字
input_year = input('工龄：')
while not input_year.isdecimal():# 判断用户输入，如果不是指定输出则重新输入
input_year = input('请输入正确的数字，工龄：')
# 获取到用户输入职位对应的最大级别，与用户输入的级别相比，如果大于则需要用户重新输入
max_year = for i in self.employee_level if i == input_job]# 获取用户职位最大的级别
input_grade = input('级别：')
while not input_grade.isdecimal() or not int(input_grade) <= max_year:# 如果用户输入不是数字且小于职位最大值则重新输入
input_grade = input(f'请输入正确的数字，级别（最大级别为{max_year}）：')
# 将用户输入传入字典中
self.employee_dict = Employee_attribute(input_name, input_job, int(input_grade), int(input_year))# 将数据传入字典
# 打印字典内的数据
for k, v in e.employee_dict.items():
print(f'key值为：{k}')
print(f'key类型为：{type(k)}')
print(f'姓名：{v.name}')
print(f'职位：{v.job}')
print(f'级别：{v.grade}')
print(f'工龄：{v.year}')
print(f'薪资：{Employee_attribute.salary(k)}')
print()
print(f'录入成功！姓名：{input_name}，工号：{self.uid_number}，薪资：{Employee_attribute.salary(self.uid_number)}')# 计算薪资
self.uid_number = str(int(self.uid_number) + 1)# 执行成功后工号加一
print()
# 查询员工数据
elif choice == '2':
user_choice = input('1.员工查询；2.职位查询；')
while user_choice not in ['1', '2']:# 规范用户输入
user_choice = input('请输入正确的数字：1.员工查询；2.职位查询；')
if user_choice == '1':# 根据用户输入的员工号查询员工信息
input_uid = input('请输入工号：')
while input_uid not in e.employee_dict:# 如果用户输入的值不在字典中则重新输入
input_uid = input('并无该工号信息，请重新输入：')
print(f'姓名：{Employee_attribute.get_name(input_uid)}')
print(f'职位：{Employee_attribute.get_job(input_uid)}')
print(f'级别：{Employee_attribute.get_grade(input_uid)}')
print(f'工龄：{Employee_attribute.get_year(input_uid)}')
print(f'薪资：{Employee_attribute.salary(input_uid)}')
print()
elif user_choice == '2':# 根据用户输入的职位查询员工信息
input_job = input('输入查询职位（E.普通员工；T.组长；M.经理）：').upper()
while input_job not in ['E', 'T', 'M']:# 判断用户输入，如果不是指定输出则重新输入
input_job = input('输入输入正确的查询职位（E.普通员工；T.组长；M.经理）：').upper()
Employee_attribute.get_job(input_job)# 根据用户输入打印职位信息
# 升级员工级别
elif choice == '3':
# 根据用户的输入查询员工信息并打印
user_number = input('请输入需要升级工号：')
while not any(k == user_number for k, v in e.employee_dict.items()):# 查询已存在的员工，如果不存在则重新输入
user_number = input('并无该工号信息，请重新输入：')
old_user_data, old_salary = Employee_attribute.user_info(user_number)# 打印用户信息并返回数据
# 根据用户输入修改员工级别
user_grade = input('请输入需要增加的级数：')
while not user_grade.isdecimal():
user_grade = input('请输入正确，需要增加的级数：')
for i in range(len(self.employee_level)):# 循环职位列表寻找对应职位
k, v = self.employee_level# 将列表中的元素提取出并赋值给k,v
if old_user_data == k:# 如果职位一致
# 情况一，员工提升后的级别在职称范围内
if (old_user_data + int(user_grade)) < v:# 如果还在自身级别内，则直接提升级别
e.employee_dict.grade = (old_user_data + int(user_grade))
# 情况二，员工提升后的级别大于职称范围内
else:# 如果大于自身级别，则升职
if i == len(self.employee_level) - 1:# 如果正在执行的循环是最后一个则将值职位调到最大
e.employee_dict.grade = self.employee_level# 将职位字典中的值赋值给员工
else:# 如果是正常升职
e.employee_dict.job = self.employee_level# 添加下一阶段的职称
e.employee_dict.grade = 1# 将值归一
print('升级成功！')
new_user_data = Employee_attribute.get_uid(user_number)# 根据用户工号获取用户信息
new_salary = Employee_attribute.salary(user_number)# 计算最新薪资
add_salary = new_salary - old_salary# 计算薪资上下幅度
add_salary = '+' + str(add_salary) if add_salary > 0 else '' + str(add_salary)# 如果结果为正整数则添加+号
print(f'{new_user_data}，工号：{user_number}，升级后职位：{new_user_data + str(new_user_data)}，升级后的薪资：{new_salary}({add_salary})')# 打印用户信息
print()
# 降级员工级别
elif choice == '4':
# 根据用户的输入查询员工信息并打印
user_number = input('请输入需要降级的工号：')
while not any(k == user_number for k, v in e.employee_dict.items()):# 查询已存在的员工，如果不存在则重新输入
user_number = input('并无该工号信息，请重新输入：')
old_user_data, old_salary = Employee_attribute.user_info(user_number)
# 根据用户输入修改员工级别
user_grade = input('请输入需要增加的级数：')
while not user_grade.isdecimal():
user_grade = input('请输入正确，需要增加的级数：')
for i in range(len(self.employee_level)):# 循环职位列表寻找对应职位
k, v = self.employee_level# 将列表中的元素提取出并赋值给k,v
if old_user_data == k:# 如果职位一致
# 情况一，员工降级后的级别在职称范围内
if (old_user_data - int(user_grade)) > 0:# 如果还在自身级别内，则直接提升级别
e.employee_dict.grade = (old_user_data - int(user_grade))
# 情况二，员工降级后的级别为负，则降级处理
else:
# 如果需要降级的职位已经是最小的级别
if i == 0:# 如果循环的次数为第一次
e.employee_dict.grade = 1# 将值归一
else:# 如果是正常降职
e.employee_dict.job = self.employee_level# 添加下一阶段的职称
e.employee_dict.grade = self.employee_level# 将职位字典中的值赋值给员工
print('降级成功！')
new_user_data = Employee_attribute.get_uid(user_number)# 根据用户工号获取用户信息
new_salary = Employee_attribute.salary(user_number)# 计算最新薪资
add_salary = new_salary - old_salary# 计算薪资上下幅度
add_salary = '+' + str(add_salary) if add_salary > 0 else '' + str(add_salary)# 如果结果为正整数则添加+号
print(f'{new_user_data}，工号：{user_number}，降级后职位：{new_user_data + str(new_user_data)}，降级后薪资：{new_salary}({add_salary})')# 打印用户信息
print()
return False# 如果输入的不是5则一直循环
if __name__ == '__main__':
e = Employee()# 实例化对象
try:
while True:
user_input_number = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
if user_input_number.isdigit():# 判断是否为数字
if 1 <= int(user_input_number) <= 5:# 如果数字为1-5
if e.employee_choice(user_input_number):
break
else:
print('请输入1到5之间的数字！')
else:
print('请输入数字！')
except KeyboardInterrupt:# 如果用户强制关闭程序也会显示
print()
print('程序结束！')
llx
重写
在不同环境下有不同功能
可以，此处加号既有数的运算又有拼接
如果有一只鸟，它走起来像鸭，游起来像鸭，叫起来像鸭，那它就是鸭
降低了耦合度
是
类继承、自定义函数
同一个运算符、函数或对象在不同的场景下，具有不同的作用效果，通用
可以
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.
降低了耦合度
不是
# 员工类：记录关键信息
class Staff:
def __init__(self,uid,name,job,grade,year):
self.uid=uid
self.name=name
self.job=job
self.grade=grade
self.year=year
# 员工方法
class Method():
#获取工号
def get_uid(self,staff):
return staff.uid
#获取姓名
def get_name(self,staff):
return staff.name
#获取职位
def get_job(self,staff):
return staff.job
#获取级别
def get_grade(self,staff):
return staff.grade
#获取工龄
def get_year(self,staff):
return staff.year
#统计并返回工资
def salary(self,staff):
if staff.job=='E':
return 3000+500*staff.grade+50*staff.year
elif staff.job=='T':
return 4000+800*staff.grade+100*staff.year
elif staff.job=='M':
return 5000+1000*(staff.grade+staff.year)
# 管理类：所有功能的实现
class Manage(Method):
def __init__(self):
self.members = {}
self.cardid = 10000
# 程序功能入口
def welcome(self):
ins = 0
while ins != '5':
ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
if ins == '1':
self.enter()
elif ins == '2':
self.query()
elif ins == '3':
self.pay_money()
elif ins == '4':
self.view_scores()
# 录入功能
def enter(self):
name=input("姓名：")
job=input("职位（E.普通员工；T.组长；M.经理）：")
year=int(input("工龄："))
grade=int(input("级别："))
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，请重新录入："))
staff=Staff(self.cardid,name,job,grade,year)
self.members = staff
print(f"录入成功！姓名：{name}，工号：{self.cardid}，薪资：{self.salary(staff)}")
self.cardid += 1
#查询功能
def query(self):
num=input("1.员工查询；2.职位查询：")
if num=='1':
cardid=int(input("请输入工号："))
if self.members.get(cardid):
print(f"姓名：{self.get_name(self.members)}\n职位：{self.get_job(self.members)}\n级别：{self.get_grade(self.members)}\n工龄：{self.get_year(self.members)}\n薪资：{self.salary(self.members)}")
else:
print("该工号不存在！")
elif num=='2':
count=0
out=[]
job=input("职位（E.普通员工；T.组长；M.经理）：")
for each in self.members:
if self.get_job(self.members)==job:
count+=1
out.append(f'{self.get_uid(self.members)} - {self.get_name(self.members)}')
print(count,out)
m = Manage()
m.welcome()
111111111
学习了上一次的习题的做法 这一次写着就顺利多了 到时候再对着答案比较一下 学到了很多