囧覅
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：同一符号、同一函数可实现不同功能
第 1 题的答案是：
第 2 题的答案是：是
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：不是
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 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 题的代码写在下方：
keep going！
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：+ * len
第 1 题的答案是：可以处理不同的场景
第 2 题的答案是：可以
第 3 题的答案是：一只鸟走起来像鸭子，叫起来像鸭子，那他就是鸭子
第 4 题的答案是：降低了耦合度
第 5 题的答案是：不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
#基类员工
class Staff:
def __init__(self,uid,name,job,grade,year):
self.name = name
self.job = job
self.grade = grade
self.year = year
self.uid = uid
def get_uid(self):
#获取工号
return self.uid
def get_name(self):
#获取姓名
return self.name
def get_job(self):
#获取职位
return self.job
def get_grade(self):
#获取级别
return self.grade
def get_year(self):
#获取工龄
return self.year
def salary(self):
#抽象方法，在子类中实现
raise NotImplementedError("Subclass must implement abstract method")
#普通员工
class Employee(Staff):
def __init__(self,uid,name,grade,year):
super().__init__(uid,name,'普通员工',grade,year)
def salary(self):
#统计并返回工资
return 3000 + 500 * self.grade + 50 * self.year
#组长
class Teamleader(Staff):
def __init__(self,uid,name,grade,year):
super().__init__(uid,name,'组长',grade,year)
def salary(self):
#统计并返回工资
return 4000 + 800 * self.grade + 100 * self.year
#经理
class Manager(Staff):
def __init__(self,uid,name,grade,year):
super().__init__(uid,name,'经理',grade,year)
def salary(self):
#统计并返回工资
return 5000 + 1000 * (self.grade + self.year)
#管理类：所有功能的实现
class Manage:
def __init__(self):
self.staff = {}
self.uid = 10000
def welcome(self):
#程序功能入口
ins = 0
while True:
ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
if ins == '1':
self.typein()
elif ins == '2':
self.inquire()
elif ins == '3':
self.upgrade()
elif ins == '4':
self.degrade()
elif ins == '5':
break
else:
print('输入错误，请重新输入！')
def typein(self):
#录入功能
name = input('姓名:')
job = input('职位（E.普通员工;T.组长;M.经理）：')
year = int(input('工龄：'))
grade = int(input('级别：'))
if job == 'E':
while grade > 10:
grade = int(input('该职位最高级别为10，请重新录入级别：'))
self.staff = Employee(self.uid,name,grade,year)
elif job == 'T':
while grade > 6:
grade = int(input('该职位最高级别为6，请重新录入级别：'))
self.staff = Teamleader(self.uid,name,grade,year)
elif job == 'M':
while grade > 3:
grade = int(input('该职位最高级别为3，请重新录入级别：'))
self.staff = Manager(self.uid,name,grade,year)
else:
print('职位输入错误，请重新输入！')
return
print(f'录入成功！姓名：{name}, 工号：{self.uid}, 薪资 {self.staff.salary()}')
self.uid += 1
def inquire(self):
#查询功能
num = input('1.员工查询;2.职位查询：')
if num == '1':
#员工查询
uid = int(input('请输入工号：'))
if not self.staff.get(uid):
print('该工号不存在！')
else:
print(f'姓名：{self.staff.name}\n'
f'职位：{self.staff.job}\n'
f'级别：{self.staff.grade}\n'
f'工龄：{self.staff.year}\n'
f'薪资：{self.staff.salary()}')
if num == '2':
#职位查询
job_2 = input('职位（E.普通员工;T.组长;M.经理）：')
job_dict = {'E':'普通员工','T':'组长','M':'经理'}
job_title = job_dict.get(job_2)
if not job_title:
print('职位输入错误，请重新输入！')
return
count = sum(1 for staff in self.staff.values() if staff.get_job() == job_title)
if count == 0:
print(f'目前公司没有{job_title}!')
else:
print(f'当前{job_title}共有{count}人：')
for staff in self.staff.values():
if staff.get_job() == job_title:
print(f'{staff.get_uid()} - {staff.get_name()}')
def upgrade(self):
#升级功能
uid = int(input('请输入工号：'))
if not self.staff.get(uid):
print('该工号不存在！')
return
staff = self.staff
print(f'{staff.get_name()}, 工号：{uid}, 当前职位：{staff.get_job()}{staff.get_grade()}, 当前薪资：{staff.salary()}')
grade_num = int(input('请输入需要增加的级数：'))
print('升级成功！')
old_salary = staff.salary()
new_grade = staff.get_grade() + grade_num
if staff.get_job() == '普通员工' and new_grade > 10:
self.staff = Teamleader(uid,staff.get_name(),1,staff.get_year())
staff = self.staff
elif staff.get_job() == '组长' and new_grade > 6:
self.staff = Manager(uid,staff.get_name(),1,staff.get_year())
staff = self.staff
elif staff.get_job() == '经理' and new_grade > 3:
print('经理职位最高级别为3，无法再升级')
return
else:
staff.grade = new_grade
change_salary = staff.salary() - old_salary
print(f'{staff.name}, 工号：{uid}, 升级后职位：{staff.job}{staff.grade}, 升级后薪资：{staff.salary()}(+{change_salary})')
def degrade(self):
#降级功能
uid = int(input('请输入工号：'))
if not self.staff.get(uid):
print('该工号不存在！')
return
staff = self.staff
print(f'{staff.get_name()}, 工号：{uid}, 当前职位：{staff.get_job()}{staff.get_grade()}, 当前薪资：{staff.salary()}')
grade_denum = int(input('请输入需要减少的级数：'))
print('降级成功！')
old_salary = staff.salary()
new_grade = staff.get_grade() - grade_denum
if staff.get_job() == '普通员工' and new_grade < 1:
print('普通员工最低级别为1，不能再降低！')
elif staff.get_job() == '组长' and new_grade < 1:
self.staff = Employee(uid,staff.get_name(),10,staff.get_year())
staff = self.staff
elif staff.get_job() == '经理' and new_grade < 1:
self.staff = Teamleader(uid,staff.get_name(),6,staff.get_year())
staff = self.staff
else:
staff.grade = new_grade
change_salary = staff.salary() - old_salary
print(f'{staff.name}, 工号：{uid}, 降级后职位：{staff.job}{staff.grade}, 降级后薪资：{staff.salary()}({change_salary})')
def main():
m = Manage()
m.welcome()
#程序主体
main()
# 0. Python 是如何体现面向对象的多态特性的？
# 方法重写：
# 子类继承父类后，可以重写父类的方法。这样，同一个方法在不同的子类中可以有不同的实现。
# 当调用这些方法时，Python会根据对象的实际类型调用相应的方法实现。
#
# 鸭子类型（Duck Typing）：
# Python是一种动态类型语言，不强制要求对象属于某个特定的类型。
# 只要对象实现了所需的方法，就可以作为某个类型来使用。
# 这意味着不同的对象只要实现了相同的方法，就可以互换使用，而不需要继承自同一个父类。
#
# 抽象基类（Abstract Base Classes, ABCs）：
# Python的abc模块允许定义抽象基类，包含抽象方法。子类必须实现这些抽象方法。
# 这样可以确保子类提供特定的方法实现，从而支持多态性。
# 1. 多态的优势是什么？
# 代码重用：
# 多态性允许在不修改现有代码的情况下添加新的功能。
# 通过继承和方法重写，可以创建新的子类，重用已有的父类代码，并对其进行扩展。
#
# 接口统一：
# 多态性提供了一种统一的接口，允许不同类型的对象通过相同的接口进行交互。
# 这使得代码更加简洁和易于理解。调用方无需了解具体的实现细节，只需知道对象具有某些方法即可。
#
# 可扩展性：
# 多态性使得系统更具扩展性。可以方便地添加新的子类和新功能，而无需对现有系统进行大规模修改。
# 这对于维护和扩展软件系统非常有利。
#
# 简化代码逻辑：
# 通过多态性，可以避免复杂的条件语句和类型检查。
# 程序可以更直接地操作对象，调用对象的方法，从而使代码更加清晰和简洁。
#
# 模块化：
# 多态性支持将程序分割成多个独立的模块，每个模块实现某个接口或抽象类的具体功能。
# 这种模块化设计提高了系统的灵活性和可维护性。
#
# 减少耦合：
# 多态性使得不同类之间的耦合度降低。调用方不需要了解对象的具体类型和实现，只需要知道对象具有什么样的方法。
# 这种松耦合设计有助于提高代码的灵活性和可维护性。
# 2. 请问在 Python 中，1+1 == 2 跟 '1' + '1' == '11'，
# 这种根据操作数类型不同，得到不同结果的现象，可以称为多态吗？
# 虽然运算符重载和多态性都涉及到不同类型的处理，但它们关注的重点不同：
# 运算符重载：同一个运算符在不同类型的操作数上有不同的行为。
# 多态性：通过统一的接口处理不同类型的对象，强调动态绑定和方法的多样性。
# 所以，1 + 1 == 2 和 '1' + '1' == '11' 的现象更确切地说是运算符重载，而不是多态。
# 3. 关于鸭子类型这个名字的来源，有一句谚语，你知道是什么吗？
# "If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck."
#
# 这句话的意思是，如果一个对象看起来像鸭子，游起来像鸭子，并且叫起来像鸭子，那么它很可能就是一只鸭子。
# 4. 高内聚低耦合，是判断软件设计好坏的标准。在程序设计中，
# 我们都希望尽可能做到高内聚（内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事，它描述的是模块内的功能联系）
# 和低耦合（耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据）。
# 那么请问，使用鸭子类型，是增强了内聚呢，还是降低了耦合度呢？
# 使用鸭子类型主要是降低了耦合度。它使得代码更加灵活和模块化，模块之间的依赖性降低，从而使得代码更易于维护和扩展。
# 虽然鸭子类型不直接增强内聚性，但通过支持模块的独立性和单一职责，间接促进了高内聚的设计。
# 5. 请问下面代码的执行结果，是属于 Python 的多态现象吗？
# def add(x, y, z=0):
# return x + y + z
#
#
# print(add(2, 3))
#
# print(add(2, 3, 4))
# 在这段代码中，add函数的行为取决于传递的参数个数，这是通过默认参数实现的，
# 不涉及对象的类型和方法的重写，所以不属于多态现象。
# 它展示的是Python中灵活的函数参数处理机制，而不是多态。
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：0
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
创造处理不同情况的子类
第 1 题的答案是：
灵活处理更多的类型、情况
第 2 题的答案是：
不，因为这个只是判断bool类型
第 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 Employee:
name = None
job = None
grade = None
year = 0
uid = None
salary = None
job_list = ['E', 'T', 'M']
def add_new(self, name, job, grade, year, uid):
self.name = name
self.job = job
self.grade = int(grade)
self.year = int(year)
self.uid = int(uid)
self.salary = int(self.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 salary(self):
job = self.get_job()
if job == 'E':
salary = 3000 + 500 * (self.get_grade()) + 50 * (self.get_year())
elif job == 'T':
salary = 4000 + 800 * (self.get_grade()) + 100 * (self.get_year())
elif job == 'M':
salary = 5000 + 1000 * ((self.get_grade()) + (self.get_year()))
return salary
def get_salary(self, job, grade, year):
if job == 'E':
salary = 3000 + 500 * grade + 50 * year
elif job == 'T':
salary = 4000 + 800 * grade + 100 * year
elif job == 'M':
salary = 5000 + 1000 * (grade + year)
return salary
class EmployeeManageMain(Employee):
job_dict = {'E': list(), 'T': list(), 'M': list()}
job_grade_dict = {'E' : 10, 'T' : 6, 'M' : 3}
employees_dict = {9999 : {'name': 'test_employee0',
'job': 'E',
'grade': 1,
'year': 1,
'uid': 9999,
'salary': 1}
}
def __init__(self):
while True:#程序主循环
option = input('\n1.录入;2.查询;3.升级;4.降级;5.退出：')
if option == '1':
self.add_new_employee()
elif option == '2':
self.check()
elif option == '3':
self.upgrade()
elif option == '4':
self.degrade()
elif option == '5':
break
def add_new_employee(self):#功能1.录入
name = input('姓名：')
while True:
job = input('职位（E.普通员工; T.组长; M.经理）：').upper()
if job not in Employee().job_list:
print('输入有误，请检查后重新输入！')
else:
break
while True:
grade = int(input('级别：'))
if job == 'E' and grade > 10:
print('输入有误，请检查后重新输入！')
elif job == 'T' and grade > 6:
print('输入有误，请检查后重新输入！')
elif job == 'M' and grade > 3:
print('输入有误，请检查后重新输入！')
else:
break
year = input('工龄：')
uid = sorted(self.employees_dict.keys())[-1] + 1
if job == 'E':
self.job_dict['E'].append(uid)
elif job == 'T':
self.job_dict['T'].append(uid)
elif job == 'M':
self.job_dict['M'].append(uid)
new_employee = Employee()
new_employee.add_new(name, job, grade, year, uid)
salary = new_employee.salary
self.employees_dict.update({uid : new_employee.__dict__})
print(f'录入成功！ 姓名：{name}, 工号：{uid}, 薪资：{salary}')
def check(self):#功能2.查询
check_option = input('1.员工查询; 2.职位查询：')
if check_option == '1': #1.员工查询
while True:
uid_checked = int(input('请输入工号：'))
if uid_checked in self.employees_dict.keys():
break
else:
print('该工号不存在，请重新输入！')
#将查询到的员工放入员工class类中，以便进行相关运算
employee_checked = self.employees_dict
#展示属性
print(f"姓名：{employee_checked['name']}\n"+ #使用+分割，避免参数之间有逗号默认的一个小空格
f"职位：{employee_checked['job']}\n"+
f"级别：{employee_checked['grade']}\n"+
f"工龄：{employee_checked['year']}\n"+
f"薪资：{employee_checked['salary']}")
elif check_option == '2': #2.职位查询
while True:
job = input('职位（E.普通员工; T.组长; M.经理）：').upper()
if job not in Employee().job_list:
print('输入有误，请检查后重新输入！')
else:
job_name = str()
if job == 'E':
job_name = '普通员工'
elif job == 'T':
job_name = '组长'
elif job == 'M':
job_name = '经理'
break
job_list = self.job_dict
if len(job_list) > 0:
print(f'目前 {job_name} 共有 {len(job_list)} 人:')
for each in job_list:
check_dict = self.employees_dict
uid = each
name = check_dict['name']
print(f'{uid} - {name}')
elif len(job_list) == 0:
print(f'目前公司没有 {job_name} !')
def upgrade(self):#功能3.升级
#指定员工（运用工号查询）
while True:
uid_checked = int(input('请输入工号：'))
if uid_checked in self.employees_dict.keys():
break
else:
print('该工号不存在，请重新输入！')
#将查询到的员工信息在全体员工dict中定位，以便进行相关运算
employee_checked = self.employees_dict
#获取属性，并展示
name = employee_checked['name']
uid = employee_checked['uid']
job = employee_checked['job']
grade = employee_checked['grade']
year = employee_checked['year']
current_job_grade = job + str(grade)
salary = employee_checked['salary']
print(f"{name}, 工号：{uid}, 当前职位：{current_job_grade}, 当前薪资：{salary}")#使用+分割，避免参数之间有逗号默认的一个小空格
#按照等级要求，增加等级
job_list = list(self.job_grade_dict.keys())
upgrade_input = int(input('请输入需要增加的级数：'))
after_grade = grade + upgrade_input
if after_grade <= self.job_grade_dict:
employee_checked['grade'] = after_grade
elif after_grade > self.job_grade_dict:#当升级后级数超过当前职位的最高级数
if job != job_list[-1]:
while True:
after_grade = after_grade - self.job_grade_dict
job = job_list
if after_grade > self.job_grade_dict:
if job == job_list[-1]:
return print('升级后的职位超出最大限制，请检查后重新输入！')
else:
continue
else:
break
else:
return print('升级后的职位超出最大限制，请检查后重新输入！')
#写入属性
grade = after_grade
employee_checked['grade'] = after_grade
employee_checked['job'] = job
current_job_grade = job + str(grade)
after_salary = self.get_salary(job, grade, year)
salary_difference = after_salary - salary
if salary_difference > 0:
salary_difference = '+' + str(salary_difference)
salary = after_salary
employee_checked['salary'] = salary
print('升级成功！')
print(f'{name}, 工号：{uid}, 升级后职位：{current_job_grade}, 升级后薪资：{salary} ({salary_difference})')
def degrade(self):#功能4.降级
#指定员工（运用工号查询）
while True:
uid_checked = int(input('请输入工号：'))
if uid_checked in self.employees_dict.keys():
break
else:
print('该工号不存在，请重新输入！')
#将查询到的员工信息在全体员工dict中定位，以便进行相关运算
employee_checked = self.employees_dict
#获取属性，并展示
name = employee_checked['name']
uid = employee_checked['uid']
job = employee_checked['job']
grade = employee_checked['grade']
year = employee_checked['year']
current_job_grade = job + str(grade)
salary = employee_checked['salary']
print(f"{name}, 工号：{uid}, 当前职位：{current_job_grade}, 当前薪资：{salary}")#使用+分割，避免参数之间有逗号默认的一个小空格
#按照等级要求，减少等级
job_list = list(self.job_grade_dict.keys())
upgrade_input = int(input('请输入需要减少的级数：'))
after_grade = grade - upgrade_input
if after_grade >= 1:
employee_checked['grade'] = after_grade
elif after_grade < 1:#当降级后级数低过当前职位的最低级数（0或负数）
if job != job_list:
while True:
job = job_list#降低一级职位
after_grade = self.job_grade_dict + after_grade#因为after_grade是0或负数，所以用加法
if after_grade < 1:
if job == job_list:
return print('降级后的职位超出最低限制，请检查后重新输入！')
else:
continue
else:
break
else:
return print('降级后的职位超出最低限制，请检查后重新输入！')
#写入属性
grade = after_grade
employee_checked['grade'] = after_grade
employee_checked['job'] = job
current_job_grade = job + str(grade)
after_salary = self.get_salary(job, grade, year)
salary_difference = after_salary - salary
if salary_difference > 0:
salary_difference = '+' + str(salary_difference)
salary = after_salary
employee_checked['salary'] = salary
print('升级成功！')
print(f'{name}, 工号：{uid}, 降级后职位：{current_job_grade}, 降级后薪资：{salary} ({salary_difference})')
main = EmployeeManageMain()
本帖最后由 GeraldKingyoung 于 2024-6-20 16:44 编辑
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
import pathlib
import pickle
if not pathlib.Path(r"C:\Users\Administrator\Desktop\baocun.txt").exists():
Max = {'E':['普通员工',10,1],'T':['组长',6,2],'M':['经理',3,3]}
jobnum = 999
name = []
position = []
age =[]
jobNum = []
level =[]
with open(r"C:\Users\Administrator\Desktop\baocun.txt",'wb') as f:
pickle.dump(Max,f)
pickle.dump(jobnum,f)
pickle.dump(name,f)
pickle.dump(position,f)
pickle.dump(age,f)
pickle.dump(jobNum,f)
pickle.dump(level,f)
else:
with open(r"C:\Users\Administrator\Desktop\baocun.txt",'rb') as f:
Max=pickle.load(f)
jobnum=pickle.load(f)
name=pickle.load(f)
position=pickle.load(f)
age=pickle.load(f)
jobNum=pickle.load(f)
level=pickle.load(f)
class Employee:
global name
global position
global age
global jobNum
global level
def writein(self):
self.name = input('姓名：')
name.append(self.name)
self.position = input('职位（E.普通员工；T.组长；M.经理）:')
position.append(self.position)
self.age = int(input('工龄：'))
age.append(self.age)
self.level = int(input('级别：'))
while self.level > Max.get(self.position):
self.level = int(input(f'该职位最高级别为{Max.get(self.position)}，请重新录入级别：'))
level.append(self.level)
global jobnum
jobnum += 1
jobNum.append(jobnum)
print(f'录入成功！姓名：{self.name}；工号：{jobnum}； 薪资：{self.salarycount(self.position,self.level,self.age)}')
def salarycount(self,position,level,age):
if position == 'E':
self.salary = 3000+500*level+50*age
elif position == 'T':
self.salary = 4000+800*level+100*age
elif position =='M':
self.salary = 5000+1000*(level+age)
return self.salary
def inquire(self):
quirenum = int(input('1.工号查询；2.职位查询'))
jishu = 0
if quirenum == 1:
quirejobnum = int(input('请输入工号：'))
for i in jobNum:
if i == quirejobnum:
_=jobNum.index(quirejobnum)
print(f'姓名：{name}，职位：{position}，级别：{level}，工龄：{age}，薪资：{self.salarycount(position,level,age)}')
jishu += 1
elif quirenum == 2:
quireposition = input('请输入职位（E.普通员工；T.组长；M.经理）：')
print(f'目前{Max.get(quireposition)}共有{len()}人：')
for j in position:
if j == quireposition:
__=position.index(quireposition)
print(f'{jobNum} - {name}')
jishu += 1
if jishu == 0:
print('查询条件不存在！')
def levelchange(self):
changenum = int(input('请输入工号：'))
if changenum in jobNum:
___=jobNum.index(changenum)
print(f'姓名：{name}，工号：{jobNum}，当前职位：{position}{level}，当前薪资：{self.salarycount(position,level,age)}')
jishu += 1
changenum = int(input('请输入改变的级数：'))
level += changenum
while level > Max.get(position):
level = level - Max.get(position)
p = Max.get(position) + 1
for key,value in Max.items():
if p == value:
position = key
while level < 1:
p = Max.get(position) - 1
for key,value in Max.items():
if p == value:
position = key
level = level + Max.get(position)
print('职级变动成功！')
print(f'姓名：{name}，工号：{jobNum}，调整后职位：{position}{level}，调整后薪资：{self.salarycount(position,level,age)}')
else:
print('查询条件不存在！')
def main():
num = int(input('1.录入；2.查询；3.职位变动；4.退出'))
while num != 4:
if num == 1:
a = Employee()
a.writein()
if num == 2:
b = Employee()
b.inquire()
if num == 3:
c = Employee()
c.levelchange()
num = int(input('1.录入；2.查询；3.职位变动；4.退出'))
else:
with open(r"C:\Users\Administrator\Desktop\baocun.txt",'wb') as f:
pickle.dump(Max,f)
pickle.dump(jobnum,f)
pickle.dump(name,f)
pickle.dump(position,f)
pickle.dump(age,f)
pickle.dump(jobNum,f)
pickle.dump(level,f)
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：不同对象的属性反馈不同
第 1 题的答案是：一函数多用
第 2 题的答案是：可以
第 3 题的答案是：捉到耗子就是好猫
第 4 题的答案是：都不是
第 5 题的答案是：不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
本帖最后由 sin0824 于 2024-6-20 09:16 编辑
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：在每个类中调用同一个种方法，返回不同的值
第 1 题的答案是：灵活性，代码维护性强
第 2 题的答案是：可以
第 3 题的答案是：一只鹅比任何鸭子都要聪明。
第 4 题的答案是：低耦合鸭子类型体现在接口的宽容度上（我们不需要关心对象具体是什么类型，只在乎它的行为方法是否符合要求即可）
第 5 题的答案是：不属于多态
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：可以
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：不是
-------- 动动手 --------
请将第 0 题的代码写在下方：
class People:
def __init__(self,name,job,grade,year,salary):
self.name = name
self.job = job
self.grade = grade
self.year = year
self.salary = salary
class Manage():
def __init__(self):
self.members = {}
self.uid = 10000
def welcome(self):#主程序
ins = 0
while ins != '5':
ins = input("1.录入;2.查询;3.升级;4.降级;5.退出:")
if ins == '1':
self.creat_member()
if ins == '2':
inst = input("1.员工查询;2.职位查询:")
if inst == '1':
self.query_member()
elif inst == '2':
self.seach_member()
if ins == '3':
self.up_member()
if ins == '4':
self.down_member()
if ins == '5':
break
def creat_member(self):#录入
name = input("姓名：")
salary = 0
select = input("职位(E.普通员工；T.组长；M.经理)：")
year = int(input("工龄："))
#grade = int(input("级别："))
grade = self.confirm_grade(select)
if select == 'E':
#sa = Employee()
#salary = sa.salary(grade,year)
salary = 3000 + 500 * grade + 50 * year
#self.job = '普通员工'
job = '普通员工'
elif select == 'T':
#sa = Teamleader()
#salary = sa.salary(grade,year)
salary = 4000 + 800 * grade + 100 * year
#self.job = '组长'
job = '组长'
elif select == 'M':
#sa = Manager()
#salary = sa.salary(grade,year)
salary = 5000 + 1000 * (grade + year)
#self.job = '经理'
job = '经理'
people = People(name,job,grade,year,salary)
self.members = people
print(f"录入成功！姓名：{self.members.name},工号：{self.uid},薪资：{self.members.salary}")
self.uid += 1
def confirm_grade(self,select):#验证级别是否超过限度
sa = int(input("级别："))
if select == 'E':
while sa > 10:
sa = int(input("该职位最高级别为10,请重新录入级别："))
elif select == 'T':
while sa > 6:
sa = int(input("该职位最高级别为6,请重新录入级别："))
elif select == 'M':
while sa > 3:
sa = int(input("该职位最高级别为3,请重新录入级别："))
return sa
def query_member(self):#员工查询
number = int(input("请输入工号:"))
if not self.members.get(number):
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}')
def seach_member(self):#职位查询
j = input("职位(E.普通员工；T.组长；M.经理)：")
if j == 'E':
b = '普通员工'
elif j == 'T':
b = '组长'
elif j == 'M':
b = '经理'
a = 0
for num in self.members:
if b == self.members.job:
a += 1
if a != 0:
print(f'目前{b}共有{a}人')
else:
print(f'目前公司没有{b}')
def up_member(self):#升职 注意跨级
inst = int(input("请输入工号:"))
if not self.members.get(inst):
print("该工号不存在！")
else:
if self.members.job == '普通员工':
j = 'E'
limit = 10
elif self.members.job == '组长':
j = 'T'
limit = 6
elif self.members.job == '经理':
j = 'M'
limit = 3
k = self.members.grade
pp = self.members.salary
print(f'{self.members.name},工号：{inst},当前职位：',end = '')
print(f',{j + str(k)}',end = '')
print(f',当前薪资{pp}')
ud = int(input("请输入需要增加的级数："))
k = k + ud
if k > limit:
k = k - limit
self.members.grade = k
if j =='E':
j ='T'
self.members.job = '组长'
self.members.salary = 4000 + 800 * k + 100 * self.members.year
elif j == 'T':
j = 'M'
self.members.job = '经理'
self.members.salary = 5000 + 1000 * (k + self.members.year)
elif j == 'M':
print('no')
else:
self.members.grade = k
if j =='E':
self.members.salary = 3000 + 500 * k + 50 * self.members.year
elif j == 'T':
self.members.salary = 5000 + 1000 * (k + self.members.year)
elif j == 'M':
self.members.salary = 5000 + 1000 * (k + self.members.year)
print("升级成功！")
print(f'{self.members.name},工号：{inst},当前职位：',end = '')
print(f',{j + str(k)}',end = '')
print(f',升级后薪资{self.members.salary}',end = '')
print(f'(+{self.members.salary - pp})')
def down_member(self):#降职
inst = int(input("请输入工号:"))
if not self.members.get(inst):
print("该工号不存在！")
else:
if self.members.job == '普通员工':
j = 'E'
elif self.members.job == '组长':
j = 'T'
limit = 10
elif self.members.job == '经理':
j = 'M'
limit = 6
k = self.members.grade
pp = self.members.salary
print(f'{self.members.name},工号：{inst},当前职位：',end = '')
print(f',{j + str(k)}',end = '')
print(f',当前薪资{pp}')
ud = int(input("请输入需要减少的级数："))
k = k - ud
if k < 1:
k = k + limit
self.members.grade = k
if j =='M':
j ='T'
self.members.job = '组长'
self.members.salary = 4000 + 800 * k + 100 * self.members.year
elif j == 'T':
j = 'E'
self.members.job = '普通员工'
self.members.salary = 3000 + 500 * k + 50 * self.members.year
elif j == 'E':
print('no')
else:
self.members.grade = k
if j =='E':
self.members.salary = 3000 + 500 * k + 50 * self.members.year
elif j == 'T':
self.members.salary = 5000 + 1000 * (k + self.members.year)
elif j == 'M':
self.members.salary = 5000 + 1000 * (k + self.members.year)
print("降级成功！")
print(f'{self.members.name},工号：{inst},当前职位：',end = '')
print(f',{j + str(k)}',end = '')
print(f',降级后薪资{self.members.salary}',end = '')
print(f'({self.members.salary - pp})')
def main():
m = Manage()
m.welcome()
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：在子类中直接对父类中要修改的方法进行修改，实现同一个方法不同作用
第 1 题的答案是：对父类中不满意的方法可以直接在子类中修改
第 2 题的答案是：不可以
第 3 题的答案是：
第 4 题的答案是：高内聚
第 5 题的答案是：不是
-------- 动动手 --------
请将第 0 题的代码写在下方：
class Member:
def __init__(self,name,zhiwei,age,jibie,pay):
self.name=name
self.zhiwei=zhiwei
self.age=age
self.jibie=jibie
self.pay=pay
class Manage:
def __init__(self):
self.member={}
self.card=10000
def a(self):
b=input('\n1.录入;2.查询;3.升级;4.降级;5.退出:')
if b=='1':
self.creat()
if b=='2':
self.seek()
if b=='3':
self.shengji()
if b=='4':
self.jiangji()
if b=='5':
return
def p(self,zhiwei,jibie,age):
if zhiwei=='M':
while jibie>3:
jibie=int(input('该职位最高级别为3，请重新录入级别：'))
pay=5000+1000*(jibie+age)
if zhiwei=='T':
while jibie>6:
jibie=int(input('该职位最高级别为6，请重新录入级别：'))
pay=4000+800*jibie+age*100
if zhiwei=='E':
while jibie>10:
jibie=int(input('该职位最高级别为10，请重新录入级别：'))
pay=3000+500*jibie+50*age
return pay,jibie
def creat(self):
name=input('姓名：')
zhiwei=input('职位（E.普通员工;T.组长;M.经理）：')
age=int(input('工龄：'))
jibie=int(input('级别：'))
pay,jibie=self.p(zhiwei,jibie,age),self.p(zhiwei,jibie,age)
member=Member(name,zhiwei,age,jibie,pay)
self.member=member
print(f'录入成功！姓名：{self.member.name},工号：{self.card},薪资：{self.member.pay}')
self.card+=1
self.a()
def seek(self):
b=input('1.员工查询；2.职位查询：')
if b=='1':
c=int(input('请输入工号：'))
if c in self.member:
print(f'姓名：{self.member.name}')
print(f'职位：{self.member.zhiwei}')
print(f'级别：{self.member.jibie}')
print(f'工龄：{self.member.age}')
print(f'薪资：{self.member.pay}')
self.a()
else:
print('该工号不存在！')
self.a()
if b=='2':
c=input('职位（E.普通员工;T.组长;M.经理）：')
t={'E':'普通员工','T':'组长','M':'经理'}
n=0
x=[]
for i in self.member:
if self.member.zhiwei==c:
n+=1
x.append(i)
print(f'目前{t}共有{n}人：')
for j in x:
print( f'{j}-{self.member.name}')
def shengji(self):
c=int(input('请输入工号：'))
print(f'{self.member.name},工号：{c},当前职位：{self.member.zhiwei}{self.member.jibie},当前薪资：{self.member.pay}')
d=int(input('请输入需要增加的级数：'))
print('升级成功！')
print(f'{self.member.name},工号：{c},当前职位：{self.member.zhiwei}{self.member.jibie},当前薪资：{self.member.pay}')
def jiangji(self):
pass
def main():
m=Manage()
m.a()
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：