1请回复您的答案^_^
-------- 问答题 --------
第 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 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：来自同一类的不同实例对象拥有不同的属性和方法
第 1 题的答案是：同一方法在不同场景中有不同的效果
第 2 题的答案是：可以 ‘+’号在不同类型之前效果不同
第 3 题的答案是：如果它看起来像鸭子，游泳像鸭子，叫声像鸭子，那么它很可能就是一只鸭子
第 4 题的答案是：鸭子类型主要通过减少模块间的依赖关系来降低耦合度，同时通过鼓励单一职责原则间接促进了内聚性的提高。
第 5 题的答案是：no
-------- 动动手 --------
请将第 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 题的答案是：
第 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 Information:
def __init__(self):
self.names = []
self.uids = []
self.jobs = []
self.grades = []
self.years = []
def get_name(self,name):
self.names.append(name)
def get_uid(self,uid):#工号
self.uids.append(uid)
def get_job(self,job):#职位
self.jobs.append(job)
def get_grade(self,grade):#级别
self.grades.append(grade)
def get_year(self,year):#工龄
self.years.append(year)
def salary(self,name):
i = self.names.index(name)
g = int(self.grades)
j = self.jobs
y = int(self.years)
if j == 'E':
s = 3000 + 500*g + 50*y
elif j == 'T':
s = 4000 + 800*g + 100*y
elif j == 'M':
s = 5000 + 1000*(g+y)
return s
class Check(Information):
def check_grade(self,job,grade):
grade = int(grade)
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，请重新录入级别：'))
return grade
def check_employee(self,u):
if self.uids.count(u) == 0:
print('该工号不存在！')
else:
i = self.uids.index(u)
return i
def check_job(self,j):
if j == 'E':
job = '普通员工'
elif j == 'T':
job = '组长'
elif j == 'M':
job = '经理'
num = self.jobs.count(j)
if num == 0:
print(f'目前公司没有{job}')
else:
return job,num
class Function(Check,Information):
def Input(self):
name = input('姓名：')
super().get_name(name)
job = input('职位（E.普通员工；T.组长；M.经理）：')
super().get_job(job)
year = input('工龄：')
super().get_year(year)
grade = input('级别：')
grade = super().check_grade(job,grade)
super().get_grade(grade)
uid = 10000+len(self.names)-1
super().get_uid(uid)
s = super().salary(name)
print(f'录入成功！姓名：{name}，工号：{uid}，薪资：{s}')
def Inquiry(self):
number = input('1.员工查询；2.职位查询：')
if number == '1':
u = int(input('请输入工号：'))
i = super().check_employee(u)
print(f'姓名：{self.names}\n职位：{self.jobs}')
print(f'级别：{self.grades}\n工龄：{self.years}')
print(f'薪资：{super().salary(self.names)}')
if number == '2':
j = input('职位（E.普通员工；T.组长；M.经理）：')
job,num = super().check_job(j)
print(f'目前{job}共有{num}人：')
for k in range(len(self.names)):
if self.jobs == j:
print(f'{self.uids} - {self.names}')
def upgrade(self):
u = int(input('请输入工号：'))
i = super().check_employee(u)
n = self.names
j = self.jobs
g = self.grades
s = super().salary(self.names)
print(f'{n},工号：{self.uids}，当前职位：{j}{g},当前薪资：{s}')
add = int(input('请输入需要增加的级数：'))
g += add
if j == 'E' and g>10:
self.jobs = 'T'
self.grades = 1
elif j == 'T' and g>6:
self.jobs = 'M'
self.grades = 1
else:
self.grades = g
print('升级成功！')
s = super().salary(self.names)
print(f'{n},工号：{self.uids}，当前职位：{self.jobs}{self.grades},当前薪资：{s}')
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：继承和重写
第 1 题的答案是：对不同的对象采取不同的操作
第 2 题的答案是：可以
第 3 题的答案是：
第 4 题的答案是：降低了耦合度
第 5 题的答案是：不是
-------- 动动手 --------
请将第 0 题的代码写在下方：
class Member:
def __init__(self,uid,name,job,year,grade):
self.uid=uid
self.name=name
self.job=job
self.year=year
self.grade=grade
class Employee(Member):
def __init__(self, uid, name, job, year, grade):
super().__init__(uid, name, job, year, grade)
while self.grade>10:
self.grade=int(input('该职位最高级别为10,请重新录入级别:'))
def salary(self):
return 3000+500*self.grade+50*self.year
class Teamleader(Member):
def __init__(self,uid, name, job, year, grade):
super().__init__(uid, name, job, year, grade)
while self.grade>6:
self.grade=int(input('该职位最高级别为6,请重新录入级别:'))
def salary(self):
return 4000+800*self.grade+100*self.year
class Manager(Member):
def __init__(self, uid, name, job, year, grade):
super().__init__(uid, name, job, year, grade)
while self.grade>3:
self.grade=int(input('该职位最高级别为3,请重新录入级别:'))
def salary(self):
return 5000+1000*self.grade+1000*self.year
class Manage:
def __init__(self):
self.code=10000
self.member={}
def operate(self):
order=int(input('1.录入；2.查询；3.升级；4.降级；5.退出'))
while not order==5:
if order==1:
self.creat_member()
if order==2:
self.view()
if order==3:
self.upgrade()
if order==4:
self.demote()
order = int(input('1.录入；2.查询；3.升级；4.降级；5.退出'))
def entering(self,uid,name,job,year,grade):
if job=='E':
self.member=Employee(uid,name,job,year,grade)
elif job=='T':
self.member=Teamleader(uid,name,job,year,grade)
elif job=='M':
self.member=Manager(uid,name,job,year,grade)
def creat_member(self):
name=input('姓名：')
uid=self.code
self.code+=1
job=input('职位（E.普通员工；T.组长；M.经理）：')
year=int(input('工龄：'))
grade=int(input('级别:'))
self.entering(uid,name,job,year,grade)
print(f'录入成功！姓名：{name},工号：{uid},薪资：{self.member.salary()}')
def view(self):
order=input('1.员工查询；2.职位查询：')
if order=='1':
num=int(input('请输入工号：'))
if num in self.member:
print(f'姓名：{self.member.name}')
print(f'职位：{self.member.job}')
print(f'级别：{self.member.grade}')
print(f'工龄：{self.member.year}')
print(f'薪资：{self.member.salary()}')
else:
print('该员工号不存在!')
elif order=='2':
job=input('职位（E.普通员工；T.组长；M.经理）：')
count=0
l=[]
for each in self.member:
if self.member.job==job:
count+=1
l.append(each)
if job=='E':
jobname='普通员工'
elif job=='T':
jobname = '组长'
elif job=='M':
jobname='经理'
if count>0:
print(f'目前{jobname}共有{count}人')
for each in l:
print(f'{each}-{self.member.name}')
else:
print(f'目前公司没有{jobname}!')
def upgrade(self):
num=int(input('请输入工号：'))
if num in self.member:
name=self.member.name
job=self.member.job
grade=self.member.grade
year=self.member.year
salary_old=self.member.salary()
print(f'{name},工号：{num},当前职位：{job}{grade}，当前薪资：{salary_old}')
self.member.pop(num)
grade_up=int(input('请输入需要增加的级数：'))
grade+=grade_up
if job=='E' and grade>10:
job='T'
grade=1
elif job=='T' and grade>6:
job='M'
grade=1
elif job=='M' and grade>3:
print('经理最高职级为3级！')
grade-=grade_up
self.entering(num, name, job, year, grade)
salary_new = self.member.salary()
print('升级成功！')
print(f'{name},工号：{num},升级后职位：{job}{grade}，升级后薪资：{salary_new}(+{salary_new-salary_old})')
else:
print('该员工号不存在!')
def demote(self):
num = int(input('请输入工号：'))
if num in self.member:
name = self.member.name
job = self.member.job
grade = self.member.grade
year = self.member.year
salary_old = self.member.salary()
print(f'{name},工号：{num},当前职位：{job}{grade}，当前薪资：{salary_old}')
self.member.pop(num)
grade_de = int(input('请输入需要减少的级数：'))
grade -= grade_de
if job == 'T' and grade <0:
job = 'M'
grade = 10
elif job == 'M' and grade <0:
job = 'T'
grade = 6
elif job == 'E' and grade < 0:
print('无法降级！')
grade -= grade_de
self.entering(num, name, job, year, grade)
salary_new = self.member.salary()
print('降级成功！')
print(f'{name},工号：{num},降级后职位：{job}{grade}，降级后薪资：{salary_new}({salary_new - salary_old})')
else:
print('该员工号不存在!')
m=Manage()
m.operate()
0001
see
请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：
0.
通过操作符、函数参数、对象的方式实现多态的。
1.相同的函数、操作符，通过输入不同类型的对象，从而得到不同类型的效果。
2.可以
3.
4.增强了内聚，但是增加了耦合
5.不是
查看答案
ss请回复您的答案^_^
-------- 问答题 --------
第 0 题的答案是：
第 1 题的答案是：
第 2 题的答案是：
第 3 题的答案是：
第 4 题的答案是：
第 5 题的答案是：
-------- 动动手 --------
请将第 0 题的代码写在下方：