P136 模板设计模式
1. 设计模式简介
设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式
设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索
2. 模板设计模式
基本介绍
- 抽象类体现的就是一种模板模式的设计，子类总体上会保留抽象类的行为方式
- 抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
模板设计模式能解决的问题
- 当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
- 编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式.
模板设计模式-最佳实践
开发需求
- 有多个类，完成不同的任务job
- 要求统计得到各自完成任务的时间
- 请编程实现【文件:模板设计模式.Py]
import time
class AA:
def job(self):
start = time.time()
num = 0
for i in range(1, 10000):
num += 1
end = time.time()
print("计算任务 执行时间(秒)", end - start)
class BB:
def job(self):
start = time.time()
num = 0
for i in range(1, 10000):
num -= 1
end = time.time()
print("计算任务 执行时间(秒)", end - start)
if __name__ == '__main__':
aa = AA()
aa.job()
bb = BB()
bb.job()
- 优化
import time
from abc import ABC, abstractmethod
class AABB(ABC):
@abstractmethod
def job(self):
pass
def cal(self):
start = time.time()* 1000
self.job()
end = time.time()* 1000
print("计算任务 执行时间(毫秒)",round ((end - start),2))
class AA(AABB):
def job(self):
num = 0
for i in range(1, 90000):
num += i
class BB(AABB):
def job(self):
num = 0
for i in range(1, 90000):
num += i
if __name__ == '__main__':
aa = AA()
aa.cal()
bb = BB()
bb.cal()
3. 本章作业
涉及知识点: 冒泡排序 | list.sort() | lambda匿名函数
- homework01.py
class Person:
def __init__(self, name, age, job):
self.name = name
self.age = age
self.job = job
def __str__(self):
return f"{self.name}-{self.age}-{self.job}"
p1 = Person("smith", 20, "java工程师")
p2 = Person("king", 18, "学生")
p3 = Person("HSP", 26, "老师")
my_list = [p1, p2, p3]
for p in my_list:
print(p)
#有3个person对象，并按照age从大到小进行排序
# 方式一 : 使用冒泡排序
def bubble_sort(my_list: list[Person]):
for i in range(1, len(my_list)):
for j in range(0, len(my_list) - i):
# 如果前面的元素 <后面的元素,就交换
if my_list[j].age < my_list[j + 1].age:
my_list[j], my_list[j + 1] = my_list[j + 1], my_list[j]
# print(f"第{i}轮排序后的结果 my_list", my_list)
print("排序后".center(32,"-"))
# bubble_sort(my_list)
#
# # print([p for p in my_list])
# #打印出来的是地址<__main__.Person object at 0x000002125112BE20>
# for p in my_list:
# print(p)
#
# 方式二 : 使用list.sort()方法
my_list.sort(key = lambda ele:ele.age,reverse=True)
my_list.sort(key = lambda ele:ele.name,reverse=True)
- homework02.py
-
子父类可以调用那些方法
class Grand:
name = "AA"
__age = 100
# def __init__(self, name, age, job):
# self.name = name
# self.age = age
# self.job = job
def g1(self):
print( f"Grand-g1()")
class Father(Grand):
id = "001"
__score = None
# super()可以访问哪些戏员(属性和方法)?
# 填写? super().name,super().g1()
# self可以访问哪些成员?
# 填写 self.id,self.__score,self.f1()
# self.name, self.g1(),
def f1(self):
print( f"Father-f1()")
class Son(Father):
name = "BB"
# super()可以访问哪些戏员(属性和方法)?
# 填写? super().id,super().f1(),super().name,super().g1()
# self可以访问哪些成员?
# 填写 self.name,self.g1(),self.__show()
# self.id,self.f1()
def g1(self):
print( f"Son-g1()")
def __show(sel):
print( f"Son-__show()")
# def hi(self):
# print( f"Son-hi()")
grand = Grand()
father = Father()
son = Son()
- homework03.py
3、编写Doctor类,属性:name, age,job, gender,sal,5个参数的构造器，重写 eq ()方法，并判断测试类中创建的两个对
象是否相等(相等就是判断属性是否相同)homework03.py
# 3、编写Doctor类,
# 属性:name, age,job, gender,sal,5个参数的构造器，
# 重写 eq ()方法，并判断测试类中创建的两个对象是否相等(相等就是判断属性是否相同)
class Doctor:
# 属性动态生成
def __init__(self, name, age, job, gender, sal):
self.name = name
self.age = age
self.job = job
self.gender = gender
self.sal = sal
# 重写eq
def __eq__(self, other):
# 如果other类型不受Doctor直接返回false
if isinstance(other, Doctor):
return self.name == other.name and \
self.age == other.age and \
self.job == other.job and \
self.gender == other.gender and\
self.sal == other.sal
return False
# 测试
doctor1 = Doctor("king",20,"牙科医","男",10000)
doctor2 = Doctor("king",21,"牙科医","男",10000)
print("doctor1==doctor2 -> ",doctor1==doctor2)
P138. Python_OOP高级知识总结
