请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：不同的对象调用同一个接口，表现出不同的状态
第 2 题的答案是：可以
第 3 题的答案是：走起来像鸭子，游起来像鸭子，叫起来也像鸭子
第 4 题的答案是：降低了耦合
第 5 题的答案是：属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
问答题：
0. Python 是如何体现面向对象的多态特性的？
Python 的多态主要通过其动态类型特性（鸭子类型）和方法重写来实现。
鸭子类型（Duck Typing） ：这是 Python 中多态最核心的体现。Python 不关心对象的实际类型，只关心对象是否拥有特定的方法。这意味着只要不同类的对象拥有相同的方法名，就可以在同一个接口下被调用，而无需显式继承或实现接口。
方法重写（Method Overriding） ：子类可以重新定义（覆盖）父类中已有的方法。当通过父类引用调用这个方法时，实际执行的是子类中重写后的方法。这是传统意义上多态的一种表现形式。
1. 多态的优势是什么？
多态（Polymorphism）是面向对象编程（OOP）的三大基本特性之一（封装、继承、多态），它的优势主要体现在以下几个方面：
1.代码复用性（Code Reusability）：
多态允许我们编写更通用的代码。例如，在之前的 `make_sound` 函数中，我们不需要为每种动物类型编写一个单独的函数（如 `make_dog_sound`, `make_cat_sound`），而是可以编写一个通用的函数来处理所有具有 `speak` 方法的对象。这大大减少了代码的重复。
2.灵活性和可扩展性（Flexibility and Extensibility）：
当需要引入新的类型时，只要新类型遵循相同的接口（即拥有相同的方法），现有的代码就无需修改。例如，如果未来我们引入一个 `Bird` 类，只要它也实现了 `speak` 方法，`make_sound` 函数就能直接处理 `Bird` 对象，而不需要修改 `make_sound` 函数本身。
这使得系统更容易扩展，因为添加新功能或新类型不会对现有代码造成破坏性影响（开闭原则：对扩展开放，对修改封闭）。
3.可维护性（Maintainability）：
由于代码更加通用和模块化，当需要修改或修复某个行为时，通常只需要修改特定类中的实现，而不会影响到使用该接口的其他部分。这降低了维护的复杂性。
4.降低耦合度（Reduced Coupling）：
多态使得调用者和被调用者之间的耦合度降低。调用者（如 `make_sound` 函数）不需要知道被调用对象（如 `dog`、`cat`）的具体类型，只需要知道它们能够响应某个特定的消息（如 `speak()`）。这种松散耦合使得系统组件更加独立，更容易测试和替换。
5.提高抽象性（Increased Abstraction）：
多态允许我们从更高层次的抽象角度来思考问题，而不是纠结于具体的实现细节。我们可以定义一个通用的行为（如“发出声音”），然后让不同的对象以自己的方式实现这个行为。
2. 请问在 Python 中，1+1 == 2 跟 '1' + '1' == '11'，这种根据操作数类型不同，得到不同结果的现象，可以称为多态吗？
1 + 1 和 '1' + '1' 的现象可以被视为多态，因为它们体现了 “同一运算符对不同类型产生不同行为” 的特性。
3. 关于鸭子类型这个名字的来源，有一句谚语，你知道是什么吗？
如果一个对象“走起来像鸭子，叫起来也像鸭子”，那么它就是鸭子。
4. 高内聚低耦合，是判断软件设计好坏的标准。在程序设计中，我们都希望尽可能做到高内聚（内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事，它描述的是模块内的功能联系）和低耦合（耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据）。那么请问，使用鸭子类型，是增强了内聚呢，还是降低了耦合度呢？
在软件设计中，鸭子类型（Duck Typing）主要通过接口抽象降低模块间的耦合度，但在一定程度上也可能间接促进高内聚。
5.请问下面代码的执行结果，是属于 Python 的多态现象吗？
>>> def add(x, y, z = 0):
... return x + y + z
...
>>> add(2, 3)
5
>>> add(2, 3, 4)
9
这段代码的执行结果不属于 Python 的多态现象。多态是指不同对象通过相同的接口展现出不同的行为，而代码体现的是函数参数默认值。
动动手：
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 级，见程序实现截图）
- 降级功能：支持减少多级；当超过当前职位最高级别时，进行升职操作（无论减少多少个级别，只要发生降职，级别一律初始化为当前职位最高级别，见程序实现截图）
录入功能实现如下：
查询功能实现如下：Po
程序升降级功能实现如下：
dai代码：
import sys
# 员工基类
class Employee:
next_uid = 10000
def __init__(self, name, job, grade, year):
self.uid = Employee.next_uid
Employee.next_uid += 1
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 get_year(self):
return self.year
def salary(self):
# This method will be overridden by subclasses
pass
def __str__(self):
return (
f"工号: {self.uid}\n"# 添加换行符
f"姓名: {self.name}\n"# 添加换行符
f"职位: {self.job}\n"# 添加换行符
f"级别: {self.grade}\n"# 添加换行符
f"工龄: {self.year}"
)
# 普通员工类
class RegularEmployee(Employee):
MAX_GRADE = 10
def __init__(self, name, grade, year):
super().__init__(name, "普通员工", grade, year)
def salary(self):
return 3000 + 500 * self.grade + 50 * self.year
# 组长类
class Teamleader(Employee):
MAX_GRADE = 6
def __init__(self, name, grade, year):
super().__init__(name, "组长", grade, year)
def salary(self):
return 4000 + 800 * self.grade + 100 * self.year
# 经理类
class Manager(Employee):
MAX_GRADE = 3
def __init__(self, name, grade, year):
super().__init__(name, "经理", grade, year)
def salary(self):
return 5000 + 1000 * (self.grade + self.year)
# 员工数据存储
employees = []
# 录入员工数据功能
def add_employee():
print("\n--- 录入员工数据 ---")
name = input("请输入员工姓名: ")
job_choice = input("请选择员工职位 (E: 普通员工, T: 组长, M: 经理): ")
try:
grade = int(input("请输入员工级别: "))
year = int(input("请输入员工工龄: "))
if job_choice == 'E':
if grade > RegularEmployee.MAX_GRADE:
print(f"普通员工最高级别为 {RegularEmployee.MAX_GRADE}，已自动调整为最高级别。")
grade = RegularEmployee.MAX_GRADE
employees.append(RegularEmployee(name, grade, year))
elif job_choice == 'T':
if grade > Teamleader.MAX_GRADE:
print(f"组长最高级别为 {Teamleader.MAX_GRADE}，已自动调整为最高级别。")
grade = Teamleader.MAX_GRADE
employees.append(Teamleader(name, grade, year))
elif job_choice == 'M':
if grade > Manager.MAX_GRADE:
print(f"经理最高级别为 {Manager.MAX_GRADE}，已自动调整为最高级别。")
grade = Manager.MAX_GRADE
employees.append(Manager(name, grade, year))
else:
print("无效的职位选择。")
return
print(f"录入成功！姓名：{name}, 工号：{employees[-1].get_uid()}, 薪资：{employees[-1].salary()}")
except ValueError:
print("输入无效，请确保级别和工龄为数字。")
# 查询功能
def search_employee():
print("\n--- 查询员工数据 ---")
search_choice = input("请选择查询方式 (1: 按工号查询, 2: 按职位查询): ")
if search_choice == '1':
try:
uid = int(input("请输入要查询的员工工号: "))
found = False
for emp in employees:
if emp.get_uid() == uid:
print(emp)
print(f"工资: {emp.salary()}")
found = True
break
if not found:
print("未找到该工号的员工。")
except ValueError:
print("输入无效，请确保工号为数字。")
elif search_choice == '2':
job_query = input("请输入要查询的职位 (普通员工, 组长, 经理): ")
found = False
print(f"\n--- {job_query} 列表 ---")
for emp in employees:
if emp.get_job() == job_query:
print(emp)
print(f"工资: {emp.salary()}")
found = True
if not found:
print(f"未找到职位为 {job_query} 的员工。")
else:
print("无效的查询方式。")
# 升级功能
def upgrade_employee():
print("\n--- 员工升级 ---")
try:
uid = int(input("请输入要升级的员工工号: "))
levels = int(input("请输入要增加的级别数: "))
found = False
for emp in employees:
if emp.get_uid() == uid:
found = True
current_job = emp.get_job()
current_grade = emp.get_grade()
new_grade = current_grade + levels
promoted = False
if current_job == "普通员工":
if new_grade > RegularEmployee.MAX_GRADE:
print("超过普通员工最高级别，进行升职操作。")
emp.job = "组长"
emp.grade = 1 # 升职后级别初始化为1
promoted = True
else:
emp.grade = new_grade
elif current_job == "组长":
if new_grade > Teamleader.MAX_GRADE:
print("超过组长最高级别，进行升职操作。")
emp.job = "经理"
emp.grade = 1 # 升职后级别初始化为1
promoted = True
else:
emp.grade = new_grade
elif current_job == "经理":
if new_grade > Manager.MAX_GRADE:
print("经理已是最高职位，级别已自动调整为最高级别。")
emp.grade = Manager.MAX_GRADE
else:
emp.grade = new_grade
if promoted:
print(f"员工 {emp.get_name()} 已升职为 {emp.get_job()}，当前级别为 {emp.get_grade()}。")
else:
print(f"员工 {emp.get_name()} 级别已更新为 {emp.get_grade()}。")
break
if not found:
print("未找到该工号的员工。")
except ValueError:
print("输入无效，请确保工号和级别数为数字。")
# 降级功能
def downgrade_employee():
print("\n--- 员工降级 ---")
try:
uid = int(input("请输入要降级的员工工号: "))
levels = int(input("请输入要减少的级别数: "))
found = False
for emp in employees:
if emp.get_uid() == uid:
found = True
current_job = emp.get_job()
current_grade = emp.get_grade()
new_grade = current_grade - levels
demoted = False
if current_job == "经理":
if new_grade < 1:
print("低于经理最低级别，进行降职操作。")
emp.job = "组长"
emp.grade = Teamleader.MAX_GRADE # 降职后级别初始化为当前职位最高级别
demoted = True
else:
emp.grade = new_grade
elif current_job == "组长":
if new_grade < 1:
print("低于组长最低级别，进行降职操作。")
emp.job = "普通员工"
emp.grade = RegularEmployee.MAX_GRADE # 降职后级别初始化为当前职位最高级别
demoted = True
else:
emp.grade = new_grade
elif current_job == "普通员工":
if new_grade < 1:
print("普通员工已是最低职位，级别已自动调整为最低级别。")
emp.grade = 1
else:
emp.grade = new_grade
if demoted:
print(f"员工 {emp.get_name()} 已降职为 {emp.get_job()}，当前级别为 {emp.get_grade()}。")
else:
print(f"员工 {emp.get_name()} 级别已更新为 {emp.get_grade()}。")
break
if not found:
print("未找到该工号的员工。")
except ValueError:
print("输入无效，请确保工号和级别数为数字。")
# 主程序循环
def main():
while True:
print("\n--- 企业员工管理系统 ---")
print("1. 录入员工数据")
print("2. 查询员工数据")
print("3. 员工升级")
print("4. 员工降级")
print("5. 退出")
choice = input("请输入您的选择: ")
if choice == '1':
add_employee()
elif choice == '2':
search_employee()
elif choice == '3':
upgrade_employee()
elif choice == '4':
downgrade_employee()
elif choice == '5':
print("退出系统。")
sys.exit()
else:
print("无效的选择，请重新输入。")
if __name__ == "__main__":
main()
请回复您的答案^_^
-------- 问答题 --------
第 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 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
#定义员工类，父类
class Staff:
def __init__(self,name,job,grade,year):
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 get_year(self):
return self.year
def salary(self):
pass
#继承父类，普通员工类
class Employee(Staff):
def __init__(self,name,job,grade,year,):
super().__init__(name,job,grade,year)
def salary(self):
return 3000 + 500 * self.grade + 50 * self.year
#继承父类，普通员工类
class Teamleader(Staff):
def __init__(self,name,job,grade,year,):
super().__init__(name,job,grade,year)
def salary(self):
return 4000 + 800 * self.grade + 100 * self.year
#继承父类，经理类
class Manager(Staff):
def __init__(self,name,job,grade,year,):
super().__init__(name,job,grade,year)
def salary(self):
return 5000 + 1000 * (self.grade + self.year)
class Manage():
user_id = 10000
staff_dict = {}
def entering(self):
name = input("姓名：")
job = input("职位(E.普通员工;T:组长;M:经理;)")
year = int(input("工龄："))
grade = int(input("级别："))
if job == "E":
mannger = Employee(name,job,grade,year)
self.staff_dict = mannger
print(f"录入成功：姓名：{name},工号：{self.user_id},薪资：{mannger.salary()}.")
self.user_id += 1
elif job == "T":
mannger = Teamleader(name,job,grade,year)
self.staff_dict = mannger
print(f"录入成功：姓名：{name},工号：{self.user_id},薪资：{mannger.salary()}.")
self.user_id += 1
elif job == "M":
mannger = Manager(name,job,grade,year)
self.staff_dict = mannger
print(f"录入成功：姓名：{name},工号：{self.user_id},薪资：{mannger.salary()}.")
self.user_id += 1
def user_id_ck(self):#输入user_id，并检查是有输入错误
user_id = int(input("请输入工号："))
while user_id not in self.staff_dict:
user_id = int(input("工号不存在，请重新输入："))
return user_id
def query(self):#查询工号/查询职位人数
query_num = int(input("1、员工查询；2、职位查询："))
if query_num == 1:
user_id = self.user_id_ck()
print(f"姓名：{self.staff_dict.name}")
print(f"职位：{self.staff_dict.job}")
print(f"级别：{self.staff_dict.grade}")
print(f"工龄：{self.staff_dict.year}")
print(f"薪资：{self.staff_dict.salary()}")
elif query_num == 2:
job = input("职位(E.普通员工;T:组长;M:经理;)")
job_num = 0
job_name = "普通员工" if job == "E" else "组长" if job == "T" else "经理"
for i in self.staff_dict.values():
if i.job == job:
job_num += 1
print(f"目前{job_name}共有{job_num}名")
for x in self.staff_dict:
if self.staff_dict.get(x).job == job:
print(f"{x} - {self.staff_dict.get(x).name}")
def up_grade(self):
user_id = self.user_id_ck()
crt_salary = self.staff_dict.salary()
print(f"{self.staff_dict.name},工号：{user_id},当前职位：{self.staff_dict.job+str(self.staff_dict.grade)},当前薪资:{crt_salary}")
up_grade_num = int(input("请输入需要增加的级数："))
self.staff_dict.grade += up_grade_num
if (self.staff_dict.job == "E") and (self.staff_dict.grade > 10):
self.staff_dict = Teamleader(self.staff_dict.name,"T",1,self.staff_dict.year)
elif (self.staff_dict.job == "T") and (self.staff_dict.grade > 6):
self.staff_dict = Manager(self.staff_dict.name,"M",1,self.staff_dict.year)
elif (self.staff_dict.job == "M") and (self.staff_dict.grade > 3):
self.staff_dict.grade = 3
print(f"{self.staff_dict.name},工号：{user_id},当前职位：{self.staff_dict.job+str(self.staff_dict.grade)},调整之后薪资:{self.staff_dict.salary()}({self.staff_dict.salary()-crt_salary:+})")
def down_grade(self):
user_id = self.user_id_ck()
crt_salary = self.staff_dict.salary()
print(f"{self.staff_dict.name},工号：{user_id},当前职位：{self.staff_dict.job+str(self.staff_dict.grade)},当前薪资:{crt_salary}")
down_grade_num = int(input("请输入需要下降的级数："))
self.staff_dict.grade -= down_grade_num
if (self.staff_dict.job == "E") and (self.staff_dict.grade < 0):
self.staff_dict.grade = 1
elif (self.staff_dict.job == "T") and (self.staff_dict.grade < 0):
self.staff_dict = Employee(self.staff_dict.name,"E",10,self.staff_dict.year)
elif (self.staff_dict.job == "M") and (self.staff_dict.grade < 0):
self.staff_dict = Teamleader(self.staff_dict.name,"T",6,self.staff_dict.year)
print(f"{self.staff_dict.name},工号：{user_id},当前职位：{self.staff_dict.job+str(self.staff_dict.grade)},调整之后薪资:{self.staff_dict.salary()}({self.staff_dict.salary()-crt_salary:+})")
def main(self):
while True:
i = int(input("1、录入；2、查询；3、升级；4、降级；5、退出；"))
if i == 5:
break
elif i == 1:
self.entering()
elif i == 2:
self.query()
elif i == 3:
self.up_grade()
elif i == 4:
self.down_grade()
m=Manage()
m.main()
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：是要有相同方法不管是什么类型都可以调用
第 1 题的答案是：一个接口可以使用多个有相同类型的方法
第 2 题的答案是：可以
第 3 题的答案是：它长得像鸭子，游泳像鸭子，叫声像鸭子，那它很可能就是鸭子
第 4 题的答案是：低耦合
第 5 题的答案是：不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
#公司员工管理
#储存员工信息
class Umessage:
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 Is_gradeMixin:
def is_grade(self,job):
grade=int(input("级别:"))
if job=='E':
while grade>10:
grade=int(input("该职位最高级别为10,请重新输入级别:"))
elif job=='T':
while grade>6:
grade=int(input("该职位最高级别为6,请重新输入级别:"))
else:
while grade>3:
grade=int(input("该职位最高级别为3,请重新输入级别:"))
return grade
#计算员工薪资
class Calculate_salaryMixin:
def calculate_salary(self,job,year,grade):
if job=='E':
salary=3000+500*grade+50*year
if job=='T':
salary=4000+800*grade+100*year
if job=='M':
salary=5000+1000*(year+grade)
return salary
class Mange(Is_gradeMixin,Calculate_salaryMixin):
def __init__(self):
self.members={}
self.uid=10000
self.numberE=0
self.numberT=0
self.numberM=0
#程序功能入口
def welcome(self):
ins=0
print("欢迎使用鱼C办公室")
while ins!='5':
ins=input("1.录入;2.查询;3.升级;4.降级;5.退出:")
if ins=='1':
self.create_account()
elif ins=='2':
choice_type=input("1.员工查询;2.职位查询:")
if choice_type=='1':
self.search_employee()
elif choice_type=='2':
self.search_position()
elif ins=='3':
self.upgrade()
elif ins=='4':
self.downgrade()
#检查是否存在工号
def check_uid(self):
uid=int(input("请输入工号:"))
while not self.members.get(uid):
uid=int(input("工号不存在,请重新输入:"))
return uid
#原等级->新等级
#升级
def change_upgrade(self,job,grade):
add_grade=int(input("请输入需要增加的级数:"))
if job=='E':
if grade+add_grade<=10:
grade+=add_grade
new_job_grade=job+str(grade)
elif grade+add_grade<16:
job='T'
grade=1
new_job_grade=job+str(grade)
self.numberT+=1
self.numberE-=1
else:
print("员工升级请谨慎考虑！！！")
elif job=='T':
if grade+add_grade<=6:
grade+=add_grade
new_job_grade=job+str(grade)
else:
job='M'
grade=1
new_job_grade=job+str(grade)
self.numberM+=1
self.numberT-=1
else:
grade+=add_grade
while grade+add_grade>3:
add_grade=int(input("已超过最高等级,请重新输入:"))
new_job_grade=job+str(grade)
return new_job_grade,job,grade
#降级
def change_downgrade(self,job,grade):
down_grade=int(input("请输入需要减少的级数:"))
if job=='E':
if 0<grade-down_grade:
grade-=down_grade
new_job_grade=job+str(grade)
else:
while grade-down_grade<=0:
down_grade=input("已低于最低等级,请重新输入:")
elif job=='T':
if 0<grade-down_grade:
grade-=down_grade
new_job_grade=job+str(grade)
elif grade-down_grade<=0:
job='E'
grade=10
new_job_grade=job+str(grade)
self.numberE+=1
self.numberT-=1
else:
if 0<grade-down_grade:
grade-=down_grade
new_job_grade=job+str(grade)
elif grade-down_grade<=0:
job='T'
grade=6
new_job_grade=job+str(grade)
self.numberM-=1
self.numberT+=1
else:
print("员工降级请谨慎考虑！！！")
return new_job_grade,job,grade
#程序功能：录入员工信息
def create_account(self):
name=input("姓名:")
job=input("职位(E.普通员工;T.组长;M.经理):")
if job=='E':
self.numberE+=1
if job=='T':
self.numberT+=1
if job=='M':
self.numberM+=1
year=int(input("工龄:"))
grade=super().is_grade(job)
salary=super().calculate_salary(job,year,grade)
member=Umessage(self.uid,name,job,grade,year,salary)
self.members=member
print(f"录入成功！姓名{name},工号:{self.uid},薪资:{salary}")
self.uid+=1
#程序功能查询：查询员工的信息，职位信息
#员工查询
def search_employee(self):
uid=self.check_uid()
member=self.members
print(f"姓名:{member.name}\n职位:{member.job}\n级别:{member.grade}\n工龄:{member.year}\n薪资:{member.salary}")
#职位信息
def search_position(self):
check_position=input("职位(E.普通员工;T.组长;M.经理):")
if check_position=='E':
if self.numberE==0:
print("目前公司没有普通员工！")
return
print(f"目前普通员工共有{self.numberE}人:")
for k,v in self.members.items():
if v.job==check_position:
print(f"{k} - {v.name}")
elif check_position=='T':
if self.numberT==0:
print("目前公司没有组长！")
return
print(f"目前组长共有{self.numberT}人:")
for k,v in self.members.items():
if v.job==check_position:
print(f"{k} - {v.name}")
elif check_position=='M':
if self.numberM==0:
print("目前公司没有经理！")
return
print(f"目前经理共有{self.numberM}人:")
for k,v in self.members.items():
if v.job==check_position:
print(f"{k} - {v.name}")
#程序功能：员工升级
def upgrade(self):
uid=self.check_uid()
member=self.members
print(f"{member.name},工号:{uid},当前职位:{member.job+str(member.grade)},当前薪资:{member.salary}")
new_grade,member.job,member.grade=self.change_upgrade(member.job,member.grade)
salary_0=member.salary
salary=super().calculate_salary(member.job,member.year,member.grade)
member.salary=salary
add_salary=salary-salary_0
print("升级成功！")
print(f"{member.name},工号:{uid},升级后的职位:{new_grade},升级后薪资{salary}(+{add_salary})")
#程序功能：员工降级
def downgrade(self):
uid=self.check_uid()
member=self.members
print(f"{member.name},工号:{uid},当前职位:{member.job+str(member.grade)},当前薪资:{member.salary}")
new_grade,member.job,member.grade=self.change_downgrade(member.job,member.grade)
salary_0=member.salary
salary=super().calculate_salary(member.job,member.year,member.grade)
member.salary=salary
down_salary=salary_0-salary
print("升级成功！")
print(f"{member.name},工号:{uid},升级后的职位:{new_grade},升级后薪资{salary}(-{down_salary})")
def main():
t=Mange()
t.welcome()
main()
不同的对象，调用同样的方法，最终得到的结果不一样。提现多态
代码简洁，可以灵活添加对象，来调用同一个方法，实现不同的结果
可以
如果它走路像鸭子，叫声像鸭子，那么它就是鸭子。
增加了内聚
不能，这只是一个默认参数的特性
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
方法重写鸭子类型运算符重载抽象基类函数参数的多态性
第 1 题的答案是：
1. 提高代码的可扩展性2. 增强代码的可维护性3. 提高代码的复用性4. 实现接口统一5. 支持更自然的问题建模6. 提高系统灵活性
第 2 题的答案是：
是的，Python 中 1 + 1 == 2 和 '1' + '1' == '11' 这种根据操作数类型不同而表现出不同行为的现象，可以称为多态的一种体现，更准确地说，这是运算符重载（Operator Overloading）实现的多态，属于特设多态（Ad-hoc Polymorphism）的一种形式。
第 3 题的答案是：
"If it looks like a duck, swims like a duck, and quacks like a duck, then it probably is a duck."
第 4 题的答案是：
软件设计中，鸭子类型（Duck Typing）主要通过降低模块间的耦合度来提升设计质量，同时对内聚性的影响相对中立（甚至可能间接增强内聚）
第 5 题的答案是：
和多态无关，因为：
没有涉及不同对象的行为差异。
没有依赖继承或接口实现。
仅仅是同一个函数对参数数量的灵活处理
-------- 动动手 --------
请将第 0 题的代码写在下方：
class Employee:
_next_uid = 10000# 工号从10000开始自动分配
def __init__(self, name, job, grade, year):
self.name = name
self.job = job
self.grade = grade
self.year = year
self.uid = Employee._next_uid
Employee._next_uid += 1
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)
def promote(self, levels=1):
max_grade = self._get_max_grade()
new_grade = self.grade + levels
# 检查是否需要升职
if new_grade > max_grade:
if self.job == "Employee":
self.job = "Teamleader"
elif self.job == "Teamleader":
self.job = "Manager"
self.grade = 1# 升职后级别重置为1
return True# 表示发生了升职
else:
self.grade = new_grade
return False
def demote(self, levels=1):
max_grade = self._get_max_grade()
new_grade = self.grade - levels
# 检查是否需要降职
if new_grade < 1:
if self.job == "Manager":
self.job = "Teamleader"
elif self.job == "Teamleader":
self.job = "Employee"
self.grade = self._get_max_grade()# 降职后级别设为新职位的最高级
return True# 表示发生了降职
else:
self.grade = new_grade
return False
def _get_max_grade(self):
if self.job == "Employee":
return 10
elif self.job == "Teamleader":
return 6
elif self.job == "Manager":
return 3
def __str__(self):
return f"UID: {self.uid}, Name: {self.name}, Job: {self.job}, Grade: {self.grade}, Years: {self.year}, Salary: {self.salary()}"
class EmployeeManagementSystem:
def __init__(self):
self.employees = []
def add_employee(self, name, job, grade, year):
if job not in ["Employee", "Teamleader", "Manager"]:
print("Invalid job type!")
return None
max_grade = 10 if job == "Employee" else (6 if job == "Teamleader" else 3)
if grade < 1 or grade > max_grade:
print(f"Invalid grade for {job}! Must be between 1 and {max_grade}.")
return None
employee = Employee(name, job, grade, year)
self.employees.append(employee)
return employee
def find_by_uid(self, uid):
for emp in self.employees:
if emp.get_uid() == uid:
return emp
return None
def find_by_name(self, name):
return
def find_by_job(self, job):
return
def promote_employee(self, uid, levels=1):
emp = self.find_by_uid(uid)
if emp:
return emp.promote(levels)
return False
def demote_employee(self, uid, levels=1):
emp = self.find_by_uid(uid)
if emp:
return emp.demote(levels)
return False
def list_all_employees(self):
return self.employees
# 测试代码
if __name__ == "__main__":
system = EmployeeManagementSystem()
# 添加员工
system.add_employee("张三", "Employee", 3, 2)
system.add_employee("李四", "Teamleader", 2, 5)
system.add_employee("王五", "Manager", 1, 10)
# 查询功能
print("=== 所有员工 ===")
for emp in system.list_all_employees():
print(emp)
print("\n=== 查询工号10000 ===")
print(system.find_by_uid(10000))
print("\n=== 查询所有经理 ===")
for emp in system.find_by_job("Manager"):
print(emp)
# 升级测试
print("\n=== 升级测试 ===")
emp = system.find_by_uid(10000)
print(f"升级前: {emp}")
system.promote_employee(10000, 8)# 普通员工3级+8=11级，超过10级，应升为组长1级
print(f"升级后: {emp}")
# 降级测试
print("\n=== 降级测试 ===")
emp = system.find_by_uid(10001)
print(f"降级前: {emp}")
system.demote_employee(10001, 3)# 组长2级-3=-1级，低于1级，应降为普通员工10级
print(f"降级后: {emp}")
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
子类可以重写父类的方法
第 2 题的答案是：
可以，对于+来说，前面是做运算，后面是做组合。对于==来说前后都是判断
第 3 题的答案是：
走起路来像鸭子，叫起来像鸭子，它就是鸭子
第 4 题的答案是：
降低了耦合度
第 5 题的答案是：
不是
-------- 动动手 --------
请将第 0 题的代码写在下方：
clerk = []
uid =
class Clerk():
def __init__(self):
self.name = input('姓名：')
self.job = input('职位（E.普通员工；T.组长；M。经理）：')
self.year = input('工龄：')
self.grade = input('级别：')
def get_uid(self):
# 计算工号
self.inputuid = uid[-1] + 1
uid.append(self.inputuid)
return self.inputuid
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_salary(self):
# 计算薪资
# 计算级别是否合理
if self.job == 'e':
while (int(self.grade) > 10):
self.grade = input('该职位最高为10，请重新入录级别：')
self.salary = 3000 + 500 * int(self.grade) + 50 * int(self.year)
elif self.job == 't':
while (int(self.grade) > 6):
self.grade = input('该职位最高为6，请重新入录级别：')
self.salary = 4000 + 800 * int(self.grade) + 100 * int(self.year)
elif self.job == 'm':
while (int(self.grade) > 3):
self.grade = input('该职位最高为3，请重新入录级别：')
self.salary = 5000 + 1000 * (int(self.grade) + int(self.year))
return self.salary
first = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
while(first != '5'):
if first == '1':
c1 = Clerk()
c1.get_uid()
c1.get_salary()
print(f"录入成功！姓名：{c1.name} 工号：{c1.inputuid} 薪资：{c1.salary}")
clerk.append(c1)
first = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
elif first == '2':
secend = input('1.员工查询；2.职位查询')
if secend == '1':
uidd = input('请输入工号：')
a = 1
for i in clerk:
if i.inputuid == int(uidd):
print('姓名：',i.get_name())
print('职位：',i.get_job())
print('级别：',i.get_grade())
print('工龄：',i.get_year())
print('薪资：',i.salary)
a = 0
if a == 1:
print('该工号不存在！')
elif secend == '2':
jobb = input('职位（E.普通员工；T.组长；M。经理）：')
b = 0
sum = 0
for i in clerk:
if jobb == i.job:
print(f"{i.job} ------ {i.get_name()}")
sum += 1
print('目前共有',sum,'人')
b = 1
if b == 0:
print('该职位没有员工')
first = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
elif first == '3':
increaseuid = input('请输入工号')
for i in clerk:
if i.inputuid == int(increaseuid):
print(f"{i.name}，工号：{i.inputuid}，"
f"当前职位：{i.job}{i.grade}，当前薪资{i.salary}")
increasegrade = input('请输入需要增加的级数')
if i.job == 'e':
gradesum = 0 + int(i.grade)
gradesum = gradesum + int(increasegrade)
elif i.job == 't':
gradesum = 10 + int(i.grade)
gradesum = gradesum + int(increasegrade)
elif i.job == 'm':
pasgradesum = 16 + int(i.grade)
gradesum = gradesum + int(increasegrade)
#计算升级后的职位等级
if gradesum < 11:
i.grade = str(gradesum)
elif gradesum < 17:
i.job = 't'
i.grade = str(gradesum - 10)
elif gradesum < 20:
i.job = 'm'
i.grade = str(gradesum - 16)
print('升级成功!')
i.get_salary()
print(f"{i.name}，工号：{i.inputuid}，"
f"升级后职位：{i.job}{i.grade}，"
f"升级后薪资{i.salary}")
first = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
elif first == '4':
decreauid = input('请输入工号')
for i in clerk:
if i.inputuid == int(decreauid):
print(f"{i.name}，工号：{i.inputuid}，"
f"当前职位：{i.job}{i.grade}，"
f"当前薪资{i.salary}")
decreagrade = input('请输入需要减少的级数')
if i.job == 'e':
gradesum = 0 + int(i.grade)
gradesum = gradesum - int(decreagrade)
elif i.job == 't':
gradesum = 10 + int(i.grade)
gradesum = gradesum - int(decreagrade)
elif i.job == 'm':
gradesum = 16 + int(i.grade)
gradesum = gradesum - int(decreagrade)
# 计算升级后的职位等级
if gradesum < 11:
i.grade = str(gradesum)
elif gradesum < 17:
i.job = 't'
i.grade = str(gradesum - 10)
elif gradesum < 20:
i.job = 'm'
i.grade = str(gradesum - 16)
print('升级成功!')
i.get_salary()
print(f"{i.name}，工号：{i.inputuid}，"
f"降级后职位：{i.job}{i.grade}，"
f"降级后薪资{i.salary}")
first = input('1.录入；2.查询；3.升级；4.降级；5.退出：')
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
1
请回复您的答案^_^
-------- 问答题 --------
第 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 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：