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，通过类的方法
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、不是
1
问答题：
0. Python 是如何体现面向对象的多态特性的？
通过重写的方式，重写了类的方法。
1. 多态的优势是什么？
在不影响类的属性的基础上，可以重新修改类的方法。
2. 请问在 Python 中，1+1 == 2 跟 '1' + '1' == '11'，这种根据操作数类型不同，得到不同结果的现象，可以称为多态吗？
可以
3. 关于鸭子类型这个名字的来源，有一句谚语，你知道是什么吗？
一只鸟长得像鸭子，叫声像鸭子，走路也像鸭子，那它就是鸭子
4. 高内聚低耦合，是判断软件设计好坏的标准。在程序设计中，我们都希望尽可能做到高内聚（内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事，它描述的是模块内的功能联系）和低耦合（耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据）。那么请问，使用鸭子类型，是增强了内聚呢，还是降低了耦合度呢？
高内聚
5. 请问下面代码的执行结果，是属于 Python 的多态现象吗？
不是
动动手：
#员工属性
class Users:
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
#计算工资
class Money:
def salary(self,job,grade,year):
if job=="E":
money=3000+500*grade+50*year
elif job=="T":
money=4000+800*grade+100*year
elif job=="M":
money=5000+1000*(grade+year)
return money
class Action(Money):
def __init__(self):
self.users={}
self.no=10000
#启动程序
def begin(self):
a=0
while a !="5":
a=input("\n1.录入；2.查询；3.升级；4.降级；5.退出：")
if a=="1":
self.insert()
elif a=="2":
self.search()
elif a=="3":
self.up()
elif a=="4":
self.down()
elif a=="5":
break
#录入
def insert(self):
name=input("姓名：")
job=input("职位（E.普通员工；T.组长；M.经理）：")
year=int(input("工龄："))
grade=int(input("级别："))
if job=="E":
if grade >10 or grade <1:
grade=int(input("该职位最高级别为10，请重新录入级别："))
elif job=="T":
if grade >6 or grade <1:
grade=int(input("该职位最高级别为6，请重新录入级别："))
elif job=="M":
if grade >3 or grade <1:
grade=int(input("该职位最高级别为3，请重新录入级别："))
uid=self.no
self.users=Users(name,job,grade,year,uid)
money=self.salary(job,grade,year)
print(f"录入成功！姓名：{name}，工号：{uid}，薪资：{money}")
self.no+=1
#查询
def search(self):
whichsearch=input("1.员工查询；2.职位查询：")
if whichsearch =="1":
uid=int(input("请输入工号："))
if not self.users.get(uid):
print("该工号不存在！")
else:
print(f"姓名：{self.users.name}")
print(f"职位：{self.users.job}")
print(f"级别：{self.users.grade}")
print(f"工龄：{self.users.year}")
print(f"薪资：{self.salary(self.users.job,self.users.grade,self.users.year)}")
if whichsearch =="2":
job=input("职位（E.普通员工；T.组长；M.经理）：")
total=0
for i in self.users:
if self.users.job==job:
total+=1
if total==0:
if job=="E":
print(f"目前公司没有普通员工！")
elif job=="T":
print(f"目前公司没有组长！")
elif job=="M":
print(f"目前公司没有经理！")
else:
print(f"目前普通员工共有{total}人：")
for i in self.users:
if self.users.job==job:
print(f"{self.users.uid} - {self.users.name}")
#升级
def up(self):
uid=int(input("请输入工号："))
print(f"{self.users.name}，工号：{uid}，当前职位：{self.users.job}{self.users.grade}，当前薪资：{self.salary(self.users.job,self.users.grade,self.users.year)}")
new=int(input("请输入需要增加的级别："))
if self.users.job=="E":
if self.users.grade+new <=10:
newgrade=self.users.grade+new
if self.users.grade+new >10 and self.users.grade <17:
newgrade=1
newjob="T"
if self.users.grade+new >=17:
newgrade=1
newjob="M"
elif self.users.job=="T":
if self.users.grade+new <=6:
newgrade=self.users.grade+new
if self.users.grade+new >6:
newgrade=1
newjob="M"
elif self.users.job=="M":
newgrade=self.users.grade+new
print("升级成功！")
print(f"{self.users.name}，工号：{uid},升级后职位：{newjob}{newgrade},升级后的薪资：{self.salary(newjob,newgrade,self.users.year)}(+{self.salary(newjob,newgrade,self.users.year)-self.salary(self.users.job,self.users.grade,self.users.year)})")
self.users.job=newjob
self.users.grade=newgrade
#降级
def down(self):
uid=int(input("请输入工号："))
print(f"{self.users.name}，工号：{uid}，当前职位：{self.users.job}{self.users.grade}，当前薪资：{self.salary(self.users.job,self.users.grade,self.users.year)}")
new=int(input("请输入需要减少的级数："))
if self.users.job=="E":
if self.users.grade-new <=0:
newgrade=self.users.grade-new
elif self.users.job=="T":
if self.users.grade+10-new >10:
newgrade=self.users.grade-new
if self.users.grade+new <=10:
newgrade=10
newjob="E"
elif self.users.job=="M":
if self.users.grade+16-new>16:
newgrade=self.users.grade-new
if self.users.grade+16-new>10 and self.users.grade+16-new<=16:
newgrade=6
newjob="T"
ifself.users.grade+16-new<=10:
newgrade=10
newjob="E"
print("降级成功！")
print(f"{self.users.name}，工号：{uid},降级后职位：{newjob}{newgrade},降级后的薪资：{self.salary(newjob,newgrade,self.users.year)}({self.salary(newjob,newgrade,self.users.year)-self.salary(self.users.job,self.users.grade,self.users.year)})")
self.users.job=newjob
self.users.grade=newgrade
def main():
m=Action()
m.begin()
0.子类可以重写父类的同名方法
1.子类可以重写父类的同名方法
2.可以
3.一只鸟长得像鸭子,叫声像鸭子,走路也像鸭子,那它就是鸭子
5.不是
问答题：
0.子类都继承了同一个父类，且都重写了父类的构造函数和方法
1.在不检查类的情况下，可以直接执行不同的子类，从而得到不同的效果
2.可以
3.黑猫白猫，能抓老鼠的就是好猫
4.高内聚，低耦合
5.不是，此代码没有继承，且只是单纯的默认参数赋值而已
动动手
0.
1
，
，
1
朕想知道
1
啊
学习
我曾经跨过山和大海,也传过人山人海
yes
answer
問答題：
0. 不同物件可以定義相同名字的方法
1. 減少需要定義的物件數量
2. 可以
3. 一支鳥走起來像鴨子，叫起來像鴨子，牠就是一隻鴨子
4. 低耦合
5. 不是
動手：
class Employee:
def __init__(self,
name,
job,
grade,
year,
uid
) -> None:
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):
if self.job == "E":
return 3000 + 500 * self.grade + 50 * self.year
if self.job == "T":
return 4000 + 800 * self.grade + 100 * self.year
if self.job == "M":
return 5000 + 1000 * (self.grade + self.year)
class Interface:
job_grade = {
"E":10,
"T":6,
"M":3
}
job_up = {
"E":"T",
"T":"M"
}
job_down = {
"T":"E",
"M":"T"
}
def __init__(self) -> None:
self.employees = {}
self.uid = 10000
def regist(self):
name = str(input("姓名："))
job = str(input("職位(E：普通員工；T：組長；M：經理)："))
year = int(input("工齡："))
grade = int(input("級別："))
while grade > Interface.job_grade:
grade = int(input(f"該職位最高級別為{Interface.job_grade}，請重新輸入級別："))
self.employees = Employee(name, job, grade, year, self.uid)
print(f"登入成功！ 姓名：{self.employees.name}，工號：{self.employees.uid}，薪資：{self.employees.salary()}")
self.uid += 1
def query_employee(self):
uid = int(input("請輸入工號："))
if not uid in self.employees:
print("該工號不存在！")
return
print(f"姓名：{self.employees.name}")
print(f"職位：{self.employees.job}")
print(f"級別：{self.employees.grade}")
print(f"工齡：{self.employees.year}")
print(f"薪資：{self.employees.salary()}")
def query_job(self):
job_name = {
"E":"普通員工",
"T":"組長",
"M":"經理"
}
job = str(input("職位(E：普通員工；T：組長；M：經理)："))
result = [ info for uid, info in self.employees.items() if info.job == job ]
print(f"目前{job_name}共有{len(result)}人：")
for each in result:
print(f"{each.uid} - {each.name}")
def query_interface(self):
function_dict = {
1:self.query_employee,
2:self.query_job
}
query = int(input("1.員工查詢；2.職位查詢："))
function_dict()
def upgrade(self):
uid = int(input("請輸入工號："))
if not uid in self.employees:
print("該工號不存在！")
return
employee = self.employees
presalary = employee.salary()
print(f"{employee.name}，工號：{employee.uid}，當前職位：{employee.job}{employee.grade}，當前薪資：{employee.salary()}")
up = int(input("請輸入需要增加的級數："))
if employee.grade + up > Interface.job_grade:
employee.job = Interface.job_up
employee.grade = 1
else:
employee.grade += up
print("升級成功！")
print(f"{employee.name}，工號：{employee.uid}，升級後職位：{employee.job}{employee.grade}，升級後薪資：{employee.salary()}({'+' if employee.salary() - presalary > 0 else ''}{employee.salary() - presalary})")
def downgrade(self):
uid = int(input("請輸入工號："))
if not uid in self.employees:
print("該工號不存在！")
return
employee = self.employees
presalary = employee.salary()
print(f"{employee.name}，工號：{employee.uid}，當前職位：{employee.job}{employee.grade}，當前薪資：{employee.salary()}")
down = int(input("請輸入需要減少的級數："))
if employee.grade - down < 1:
employee.job = Interface.job_down
employee.grade = Interface.job_grade
else:
employee.grade -= down
print("降級成功！")
print(f"{employee.name}，工號：{employee.uid}，降級後職位：{employee.job}{employee.grade}，降級後薪資：{employee.salary()}({'+' if employee.salary() - presalary > 0 else ''}{employee.salary() - presalary})")
def start(self):
function_dict = {
1:self.regist,
2:self.query_interface,
3:self.upgrade,
4:self.downgrade,
}
while True:
query = int(input("1.登錄；2.查詢；3.升級；4.降級；5.退出："))
if query == 5:
break
function_dict()
interface = Interface()
interface.start()
0.python中的+和*遇到不同的类型会执行不同的运算
1.通过改变不同的场景，用同一种方法、函数、对象来实现不同的效果，可以显著减少代码的复杂程度
2.可以
3.“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
4.降低了耦合？
5.不是
0.
class Staff:
def __init__(self,name,grade,year,uid):
self.name = name
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
class Employee(Staff):
member = []
def __init__(self,name,grade,year,uid):
self.job = "Employee"
grade = "E" + str(grade)
super().__init__(name,grade,year,uid)
Employee.member +=
def salary(self):
return 3000 + 500 * int(self.grade) + 50 * self.year
class Teamleader(Staff):
member = []
def __init__(self,name,grade,year,uid):
self.job = "Teamleader"
grade = "T" + str(grade)
super().__init__(name,grade,year,uid)
Teamleader.member +=
def salary(self):
return 4000 + 800 * int(self.grade) + 100 * self.year
class Manager(Staff):
member = []
def __init__(self,name,grade,year,uid):
self.job = "Manager"
grade = "M" + str(grade)
super().__init__(name,grade,year,uid)
Manager.member +=
def salary(self):
return 5000 + 1000 * (int(self.grade) + self.year)
class Manage:
def __init__(self):
self.staff = dict()
self.uid = 10000
def program(self):
ins = 0
while ins != '5':
ins = input("\n1.录入;2.查询;3.升级;4.降级;5.退出：")
if ins == '1':
self.enter()
elif ins == '2':
self.search()
elif ins == '3':
self.upgrade()
elif ins == '4':
self.downgrade()
elif ins != "5":
print("请输入正确的指令")
def confirm_uid(self):
uid = int(input("请输入工号："))
if not self.staff.get(uid):
print("该工号不存在！")
return 0
else:
return uid
def confirm_job(self):
job = input("职位（E.普通员工；T.组长；M.经理）：")
while job not in('E','T','M'):
print("请输入正确的指令")
job = input("职位（E.普通员工；T.组长；M.经理）：")
return job
def enter(self):
name = input("姓名：")
job = self.confirm_job()
year = int(input("工龄："))
if job == "E":
grade = int(input("级别："))
while grade > 10:
grade = int(input("该职位最高级别为10，请重新录入级别："))
self.staff = Employee(name,grade,year,self.uid)
elif job == "T":
grade = int(input("级别："))
while grade > 6:
grade = int(input("该职位最高级别为6，请重新录入级别："))
self.staff = Teamleader(name,grade,year,self.uid)
else:
grade = int(input("级别："))
while grade > 3:
grade = int(input("该职位最高级别为3，请重新录入级别："))
self.staff = Manager(name,grade,year,self.uid)
print(f"录入成功！姓名：{name}，工号：{self.uid},薪资：{self.staff.salary()}")
self.uid += 1
def search(self):
ins = input("1.员工查询；2.职位查询：")
if ins == '1':
uid = self.confirm_uid()
if uid:
print(f"姓名：{self.staff.name}\n职位：{self.staff.job}\n级别：{self.staff.grade}\n工龄：{self.staff.year}\n薪资：{self.staff.salary()}")
elif ins == '2':
job = self.confirm_job()
if job == "E":
job = "普通员工"
member = Employee.member
elif job == "T":
job = "组长"
member = Teamleader.member
else:
job = "经理"
member = Manager.member
if len(member) != 0:
print(f"目前{job}共有{len(member)}人")
for each in member:
print(f"{each} - {self.staff.name}")
else:
print(f"目前公司没有{job}！")
def upgrade(self):
uid = self.confirm_uid()
if uid:
grade = self.staff.grade
salary = self.staff.salary()
print(f"{self.staff.name}，工号：{uid}，当前职位：{grade}，当前薪资：{self.staff.salary()}")
num = int(input("请输入需要增加的级数："))
if grade == "E":
if int(grade) + num <= 10:
self.staff.grade = "E" + str(int(grade)+num)
else:
grade = 1
self.staff = Teamleader(self.staff.name,grade,self.staff.year,uid)
Employee.member.remove(uid)
elif grade == 'T':
if int(grade) + num <= 6:
self.staff.grade = "T" + str(int(grade)+num)
else:
grade = 1
self.staff = Manager(self.staff.name,grade,self.staff.year,uid)
Teamleader.member.remove(uid)
else:
if int(grade) + num <= 3:
self.staff.grade = "M" + str(int(grade)+num)
else:
print("请输入正确的级数！")
return
print("升级成功！")
print(f"{self.staff.name}，工号：{uid}，升级后职位：{self.staff.grade}，升级后薪资：{self.staff.salary()}（+{self.staff.salary()-salary}）")
def downgrade(self):
uid = self.confirm_uid()
if uid:
grade = self.staff.grade
salary = self.staff.salary()
print(f"{self.staff.name}，工号：{uid}，当前职位：{grade}，当前薪资：{self.staff.salary()}")
num = int(input("请输入需要增加的级数："))
if grade == "E":
if int(grade) - num > 0:
self.staff.grade = "E" + str(int(grade)-num)
else:
print("请输入正确的级数！")
return
elif grade == 'T':
if int(grade) - num > 0:
self.staff.grade = "T" + str(int(grade)-num)
else:
grade = 6
self.staff = Employee(self.staff.name,grade,self.staff.year,uid)
Teamleader.member.remove(uid)
else:
if int(grade) - num > 0:
self.staff.grade = "E" + str(int(grade)-num)
else:
grade = 6
self.staff = Teamleader(self.staff.name,grade,self.staff.year,uid)
Manager.member.remove(uid)
print("降级成功！")
print(f"{self.staff.name}，工号：{uid}，降级后职位：{self.staff.grade}，降级后薪资：{self.staff.salary()}(-{salary-self.staff.salary()})")
def main():
manage =Manage()
manage.program()