HSP_15章 Python_模板设计模式和oop进阶总结

P136 模板设计模式

1. 设计模式简介

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式
设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索

在这里插入图片描述

2. 模板设计模式

基本介绍
- 抽象类体现的就是一种模板模式的设计，子类总体上会保留抽象类的行为方式
- 抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
模板设计模式能解决的问题
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)