请回复您的答案^_^
-------- 问答题 --------
第 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 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：class Member:
def __init__(self,name,job,grade,year,uid):
self.name = name
self.job = job
self.grade = grade
self.year = year
self.uid = uid
class Manage:
def __init__(self):
self.members = {}
self.uid = 10000
def create_member(self):
uid = self.get_uid()
name = self.get_name()
job = self.get_job()
year = self.get_year()
grade = self.get_grade(job)
self.members = Member(name,job,grade,year,uid)
print(f"录入成功！姓名：{name},工号：{uid}，薪资{self.salary(uid)}")
def query(self):
ins = 0
while ins not in ('1','2'):
ins = input("1.员工查询;2.职位查询：")
if ins == '1':
self.employee_query()
if ins == '2':
self.position_query()
def employee_query(self):
uid = self.confirm()
if uid:
print(f"""
姓名：{self.members.name}
职位：{self.members.job}
级别：{self.members.grade}
工龄：{self.members.year}
薪资：{self.salary(uid)}
""".strip('\n'))
def position_query(self):
job = self.get_job()
text =
k = {'E':"普通员工",'T':"组长",'M':"经理"}
if len(text):
print(f"目前{k}共有{len(text)}人：\n{"\n".join(text)}")
else:
print(f"目前公司没有{k}!")
def upgrade(self):
text = {'E':10 ,'T':6 ,'M':3 }
uid = self.confirm()
if not uid:
return None
ord_salary = self.salary(uid)
print(f"{self.members.name}，工号：{uid}，当前职位：{self.members.job}{self.members.grade}，当前薪资：{self.salary(uid)}")
level_up = int(input("请输入需要增加的级数："))
level = self.members.grade + level_up
if level <= text.job]:
self.members.grade = level
elif level > text.job] and self.members.job != 'M':
self.members.grade = 1
if self.members.job == 'E':
self.members.job = 'T'
if self.members.job == 'T':
self.members.job = 'M'
else:
print("等级数据异常，升级失败")
return None
print(f"{self.members.name}，工号：{uid}，升级后职位：{self.members.job}{self.members.grade}，升级后薪资：{self.salary(uid)}(+{self.salary(uid) - ord_salary})")
def downgrade(self):
text = {'E':10 ,'T':6 ,'M':3 }
uid = self.confirm()
if not uid:
return None
ord_salary = self.salary(uid)
print(f"{self.members.name}，工号：{uid}，当前职位：{self.members.job}{self.members.grade}，当前薪资：{self.salary(uid)}")
level_down = int(input("请输入需要减少的级数："))
level = self.members.grade - level_down
if level > 0:
self.members.grade = level
elif level <= 0 and self.members.job != 'E':
if self.members.job == 'T':
self.members.job = 'E'
if self.members.job == 'M':
self.members.job = 'T'
self.members.grade = text.job]
else:
print("等级数据异常，降级失败")
return None
print(f"{self.members.name}，工号：{uid}，降级后职位：{self.members.job}{self.members.grade}，降级后薪资：{self.salary(uid)}(-{ord_salary - self.salary(uid)})")
def confirm(self):
uid = int(input("请输入工号："))
if self.members.get(uid):
return uid
else :
print("该工号不存在!")
def get_uid(self):
uid = self.uid
self.uid += 1
return uid
def get_name(self):
name = input("姓名：")
return name
def get_job(self):
job = input("职位（E.普通员工;T.组长;M.经理）：")
while job not in ('E','T','M'):
job = input("请输入正确的职位符号：")
return job
def get_grade(self,job):
text = {'E':10 ,'T':6 ,'M':3 }
max_grade = text
grade = int(input("级别："))
while not 1 <= grade <= max_grade:
grade = int(input(f"该职位最高级别为{max_grade}，请重新录入级别："))
return grade
def get_year(self):
while True:
try:
year = int(input("工龄："))
if year < 0:
raise ValueError
except ValueError:
print("请输入正整数")
else:
return year
def salary(self,uid):
text = {'E':3000 + 500 * self.members.grade + 50 * self.members.year,
'T':4000 + 800 * self.members.grade + 100 * self.members.year,
'M':5000 + 1000 * (self.members.grade + self.members.year)}
return text.job]
def welcome(self):
ins = 0
while ins != '5':
ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
if ins == '1':
self.create_member()
if ins == '2':
self.query()
if ins == '3':
self.upgrade()
if ins == '4':
self.downgrade()
def main():
m = Manage()
m.welcome()
main()
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：继承和重写
第 1 题的答案是：可扩展性，代码重用，简化复杂性，提高可读性和可维护性
第 2 题的答案是：不能
第 3 题的答案是：看它走起路来像鸭子、叫起来像鸭子，那么它就是鸭子
第 4 题的答案是：降低耦合度
第 5 题的答案是：不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
class Staff:
name = ""
job = ""
grade = 0
year = 0
uid = 10000
def __init__(self, name, job, grade, year, uid):
self.name = name
self.job = job
self.grade = grade
self.year = year
self.uid = uid
def get_uid(self):
return self.uid
def get_name(self):
return self.name
def get_job(self):
return self.job
def get_grade(self):
return self.grade
def get_year(self):
return self.year
def set_uid(self):
self.uid += 1
def salary(self):
pass
def promote(steps):
pass
def demote(steps):
pass
class Employee(Staff):
def __init__(self, name, job, grade, year, uid):
super().__init__(name, job, grade, year, uid)
def salary(self):
return 3000 + 500 * self.grade + 50 * self.year
def promote(self, steps):
self.grade += steps
if self.grade > 10:
self.job = "TeamLeader"
self.grade = 1
print(f"{self.get_name()} promoted to grade {self.get_grade()}")
class Teamleader(Staff):
def __init__(self, name, job, grade, year, uid):
super().__init__(name, job, grade, year, uid)
def salary(self):
return 4000 + 800 * self.grade + 100 * self.year
def promote(self, steps):
self.grade += steps
if self.grade > 6:
self.job = "Manager"
self.grade = 1
print(f"{self.get_name()} promoted to grade {self.get_grade()}")
def demote(self, steps):
self.grade -= steps
if self.grade < 1:
self.job = "Employee"
self.grade = 10
print(f"{self.get_name()} demoted to grade {self.get_grade()}")
class Manager(Staff):
def __init__(self, name, job, grade, year, uid):
super().__init__(name, job, grade, year, uid)
def salary(self):
return 5000 + 1000 * (self.grade + self.year)
def demote(self, steps):
self.grade -= steps
if self.grade < 1:
self.job = "TeamLeader"
self.grade = 6
print(f"{self.get_name()} demoted to grade {self.get_grade()}")
class Manage:
def __init__(self):
self.staff = []
def add_staff(self, staff):
self.staff.append(staff)
def welcome(self):
self.staff = []
self.uid = 10000
print("Welcome to the Staff Management System")
for member in self.staff:
print(f"Name: {member.get_name()}, Job: {member.get_job()}, Salary: {member.salary()}")
def main():
m = Manage()
m.welcome()
请回复您的答案^_^
-------- 问答题 --------
第 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 题的代码写在下方：
看看
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
只要符合要求，就能创建一个函数，给出输入，就会给输出。
第 1 题的答案是：
可以简化反复调用相同的方法
第 2 题的答案是：
是的
第 3 题的答案是：
不管是鸡鸭鸟，都是有相同的构造。
第 4 题的答案是：
降低了耦合度
第 5 题的答案是：
是的
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：通过函数，运算符，对象在不同情节下的不同功能，例如len()计算字符串和列表的情境
第 1 题的答案是：在不同情境下，具有不同的功能
第 2 题的答案是：可以
第 3 题的答案是：不知道
第 4 题的答案是：降低了耦合度
第 5 题的答案是：不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
不同类的对象对同一消息（方法调用）做出不同的响应。
第 1 题的答案是：
“一个接口，多种实现”。你不需要关心对象具体是什么类型，只关心它有没有你需要的方法。
第 2 题的答案是：
可以
第 3 题的答案是：
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
第 4 题的答案是：
耦合
第 5 题的答案是：
不是
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
## 0. 请按要求编写一个企业员工管理程序
class Staff_Init:
def __init__(self,name,uid,job,year,grade):
self.name = name
self.uid = uid
self.job = job
self.year = year
self.grade = grade
def get_name(self):
return self.name
def get_uid(self):
return self.uid
def get_job(self):
return self.job
def get_year(self):
return self.year
def get_grade(self):
return self.grade
def get_salary(self):
if self.job == 'E':
self.salary = 3000 + 500*self.grade + 50*self.year
elif self.job == 'T':
self.salary = 4000 + 800*self.grade + 100*self.year
elif self.job == 'M':
self.salary = 5000 + 1000*(self.grade + self.year)
return self.salary
class Employee(Staff_Init):
def __init__(self,name,uid,job,year,grade):
super().__init__(name,uid,job,year,grade)
class Teamleader(Staff_Init):
def __init__(self,name,uid,job,year,grade):
super().__init__(name,uid,job,year,grade)
class Manager(Staff_Init):
def __init__(self,name,uid,job,year,grade):
super().__init__(name,uid,job,year,grade)
class checkMixin:
def check_job(self,job):
while job != 'E' and job != 'T' and job != 'M':
job = input('请输入正确的职位代号(E.普通员工;T.组长;M.经理):')
return job
def check_grade(self,grade,job):
while True:
if grade.isnumeric():
grade = int(grade)
if job == 'E':
if grade <= 10:
break
else:
grade = input('最高级别为10，请重新录入级别:')
elif job == 'T':
if grade <= 6:
break
else:
grade = input('最高级别为6，请重新录入级别:')
else:
if grade <= 3:
break
else:
grade = input('最高级别为3，请重新录入级别:')
else:
grade = input('请输入数字:')
return grade
def check_number(self,string):
while not string.isnumeric():
string = input('请输入数字:')
return int(string)
class changeMixin:
def change_upgrade(self,job,grade,upgrade):
if job == 'E':
grade_new = grade + upgrade
if grade_new>10:
return 'T', 1
else:
return 'E', grade_new
if job == 'T':
grade_new = grade + upgrade
if grade_new>6:
return 'M', 1
else:
return 'T', grade_new
if job == 'M':
grade_new = grade + upgrade
if grade_new>3:
return 'M', 3
else:
return 'M', grade_new
def change_downgrade(self,job,grade,downgrade):
if job == 'E':
grade_new = grade - downgrade
if grade_new<=0:
return 'E', 1
else:
return 'E', grade_new
if job == 'T':
grade_new = grade - downgrade
if grade_new<=0:
return 'E', 10
else:
return 'T', grade_new
if job == 'M':
grade_new = grade - downgrade
if grade_new<=0:
return 'T', 6
else:
return 'M', grade_new
class Mune(checkMixin,changeMixin):
number = 10000
staffs = {}
def welcome(self):
ins = 0
while ins != '5':
ins = input('\n1.录入；2.查询；3.升级；4.降级；5.退出：')
if ins == '1':
self.creat_staff()
if ins == '2':
self.check_staff()
if ins == '3':
self.upgrade_staff()
if ins == '4':
self.downgrade_staff()
def creat_staff(self):
name = input('姓名：')
uid = Mune.number
Mune.number += 1
job = self.check_job(input('职位（E.普通员工;T.组长;M.经理）：'))
grade = self.check_grade(input('级别：'),job)
year = self.check_number(input('工龄：'))
if job == 'E':
self.staffs = Employee(name,uid,job,year,grade)
elif job == 'T':
self.staffs = Teamleader(name,uid,job,year,grade)
elif job == 'M':
self.staffs = Manager(name,uid,job,year,grade)
print(f'录入成功！姓名：{name}，工号：{uid}，薪资：{self.staffs.get_salary()}')
def check_staff(self):
ins = input('1.员工查询;2.职位查询;输入其他退出：')
if ins == '1':
uid = self.check_number(input('卡号：'))
if uid>9999 and uid<Mune.number:
print(f'姓名：{self.staffs.name}')
print(f'职位：{self.staffs.job}')
print(f'级别：{self.staffs.grade}')
print(f'工龄：{self.staffs.year}')
print(f'薪资：{self.staffs.get_salary()}')
else:
print('改工号不存在！')
elif ins == '2':
job = self.check_job(input('职位（E.普通员工;T.组长;M.经理）：'))
count_staffs =
if job == 'E':
print(f'目前普通员工共有{len(count_staffs)}人')
elif job == 'T':
print(f'目前组长共有{len(count_staffs)}人')
elif job == 'M':
print(f'目前经理共有{len(count_staffs)}人')
for i in count_staffs:
print(f'{i.uid} - {i.name}')
def upgrade_staff(self):
uid = self.check_number(input('卡号：'))
if uid < Mune.number and uid > 9999:
name = self.staffs.name
job, grade = self.staffs.job, self.staffs.grade
year = self.staffs.year
salary1 = self.staffs.get_salary()
print(f'{name}，工号：{uid}，当前职位：{job}{grade}，当前薪资：{salary1}')
upgrade = self.check_number(input('请输入需要增加的级数：'))
job, grade = self.change_upgrade(job,grade,upgrade)
if job == 'E':
self.staffs = Employee(name,uid,job,year,grade)
elif job == 'T':
self.staffs = Teamleader(name,uid,job,year,grade)
elif job == 'M':
self.staffs = Manager(name,uid,job,year,grade)
salary2 = self.staffs.get_salary()
print('升级成功！')
print(f'{name}，工号：{uid}，升级后职位{job}{grade}，升级后薪资{salary2}(增加{salary2-salary1})')
else:
print('卡号不存在！')
def downgrade_staff(self):
uid = self.check_number(input('卡号：'))
if uid < Mune.number and uid > 9999:
name = self.staffs.name
job, grade = self.staffs.job, self.staffs.grade
year = self.staffs.year
salary1 = self.staffs.get_salary()
print(f'{name}，工号：{uid}，当前职位：{job}{grade}，当前薪资：{salary1}')
downgrade = self.check_number(input('请输入需要减少的级数：'))
job, grade = self.change_downgrade(job,grade,downgrade)
if job == 'E':
self.staffs = Employee(name,uid,job,year,grade)
elif job == 'T':
self.staffs = Teamleader(name,uid,job,year,grade)
elif job == 'M':
self.staffs = Manager(name,uid,job,year,grade)
salary2 = self.staffs.get_salary()
print('降级成功！')
print(f'{name}，工号：{uid}，降级后职位{job}{grade}，降级后薪资{salary2}(减少{salary1-salary2})')
else:
print('卡号不存在！')
def main():
mune = Mune()
mune.welcome()
main()
请回复您的答案^_^
-------- 问答题 --------
第 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 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
对于不同的对象，都能按照方法输出
第 1 题的答案是：
同一段代码多个对象都能使用
第 2 题的答案是：
不是，是运算符重载
第 3 题的答案是：
如果它看起来像鸭子、游泳像鸭子、叫声像鸭子，那么它很可能就是一只鸭子。
第 4 题的答案是：
低耦合
第 5 题的答案是：
不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：同一个方法不同的结果
第 1 题的答案是：优雅
第 2 题的答案是：可以
第 3 题的答案是：鸭子
第 4 题的答案是：内聚
第 5 题的答案是：不属于
-------- 动动手 --------
请将第 0 题的代码写在下方：class Member:
def __init__(self,card,name,job,grade,year):
self.card=card
self.name=name
self.job=job
self.grade=grade
self.year=year
class Employee:
def salary(self,grade,year):
return 3000+500*int(grade)+50*int(year)
def get_grade(self):
grade=input('your grade')
while True:
try:
if int(grade)>10:
int('q')
break
except ValueError:
grade=input('重新输入')
return grade
class Teamleader:
def salary(self,grade,year):
return 4000+800*int(grade)+100*int(year)
def get_grade(self):
grade=input('your grade')
while True:
try:
if int(grade)>6:
int('q')
break
except ValueError:
grade=input('重新输入')
return grade
class Manager:
def salary(self,grade,year):
return 5000+1000*(int(grade)+int(year))
def get_grade(self):
grade=input('your grade')
while True:
try:
if int(grade)>3:
int('q')
break
except ValueError:
grade=input('重新输入')
return grade
class Worker:
def __init__(self):
self.member={}
self.card=10000
self.cat={'E':10,'T':6,'M':3}
def get_uid(self):
return self.card
def get_name(self):
name=input('your name')
return name
def get_job(self):
job=input('your job(E普通员工，T组长，M经理')
while job not in ['M','T','E']:
job = input('your job(E普通员工，T组长，M经理')
return job
def get_year(self):
year=input('your year')
while True:
try:
int(year)
break
except ValueError:
year = input('重新输入')
return year
def lot(self,card,s):
e = Employee()
t = Teamleader()
m = Manager()
if s == 'E':
return e.get_grade()
elif s == 'T':
return t.get_grade()
elif s == 'M':
return m.get_grade()
def many(self,card,s):
e=Employee()
t=Teamleader()
m=Manager()
if s=='E':
return e.salary(self.member.grade,self.member.year)
elif s=='T':
return t.salary(self.member.grade, self.member.year)
elif s=='M':
return m.salary(self.member.grade, self.member.year)
def introduce(self,cardid):
while True:
try:
if int(cardid) in self.member:
d = self.member
print(f'名字{d.name}\n职位{d.job}\n级别{d.grade}\n工龄{d.year}\n工资{self.many(int(cardid), d.job)}')
break
else:
print('该卡号不存在')
except ValueError:
print('重新输入一个数字')
def main(self):
x=0
while x!='5':
x=input('1录入2查询3升级4降级5退出')
if x=='1':
name=self.get_name()
job=self.get_job()
year=self.get_year()
card=self.get_uid()
grade = self.lot(card,job)
self.member=Member(card,name,job,grade,year)
print(f'完成了,卡号是{self.card}')
self.card+=1
elif x=='2':
y=0
who=input('1.员工查询 2.职位查询')
if who=='1':
cardid = input('card')
self.introduce(cardid)
elif who=='2':
jobe=input('职位（E.普通员工；T.组长；M.经理）')
namee={}
for i in self.member:
if self.member.job==jobe:
y+=1
namee=self.member.name
if namee:
print(f'总共找到了{y}个')
.name} {j}') for j in namee]
elif x=='3':
cardid = input('card')
self.introduce(cardid)
simple=input('请输入要增加的级数')
if simple=='1' and self.member.grade=='M':
print()
w=Worker()
w.main()
请回复您的答案^_^
-------- 问答题 --------111
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：它允许不同类的对象对同一消息（方法调用）做出不同的响应，Python 的多态主要依赖于其动态类型和鸭子类型的特性
第 1 题的答案是：
提高代码灵活性：可以编写适用于多种类型的通用函数，如 animal_sound(animal)。
增强可扩展性：添加新类时，只要新类遵循已有的接口（如都有 speak方法），无需修改现有函数代码。
减少代码冗余：通过统一的接口操作不同对象，避免了为每种类型编写重复的逻辑。
第 2 题的答案是：可以的，其中‘+’在这两个操作中扮演的是不一样的功能，第一个是作为运算符号使用，第二个只是将两个字符串合并到一起
第 3 题的答案是：源于“如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子”的理念
第 4 题的答案是：主要还是降低了耦合度
第 5 题的答案是：代码展示了 Python 中函数参数默认值的用法，这并不属于面向对象编程中多态（Polymorphism） 的典型范畴。
-------- 动动手 --------
请将第 0 题的代码写在下方：