设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。
0:接口
定义:一种特殊的类,声明了若干方法,要求继承该接口的类必须实现这种方法
作用:限制继承接口的类的方法的名称及调用方式,隐藏了类的内部实现
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):
@abstractmethod#定义抽象方法的关键字
def pay(self,money):
pass
# @abstractmethod
# def pay(self,money):
# raise NotImplementedError
class AiliPay(Payment):
#子类继承接口,必须实现接口中定义的抽象方法,否则不能实例化对象
def pay(self,money):
print('使用支付宝支付%s元'%money)
class ApplePay(Payment):
def pay(self,money):
print('使用苹果支付支付%s元'%money)
1、单例模式
单例模式(Singleton Pattern)是一种常用的软件设计模式,该模式的主要目的是确保某一个类只有一个实例存在。在整个系统中,某个类只能出现一个实例时,单例对象就能派上用场。
定义:保证一个类只有一个实例,并提供一个访问它的全局访问点
适用场景:当一个类只能有一个实例,而客户可以从一个众所周知的访问点访问它时
优点
- 1、在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例(比如管理学院首页页面缓存)。
- 2、避免对资源的多重占用(比如写文件操作)。
比如,某个服务器程序的配置信息存放在一个文件中,客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间,有很多地方都需要使用配置文件的内容,也就是说,很多地方都需要创建 AppConfig 对象的实例,这就导致系统中存在多个 AppConfig 的实例对象,而这样会严重浪费内存资源,类似 AppConfig 这样的类,我们希望在程序运行期间只存在一个实例对象。
class Singleton(object):
#如果该类已经有了一个实例则直接返回,否则创建一个全局唯一的实例
def __new__(cls, *args, **kwargs):
if not hasattr(cls,'_instance'):
cls._instance = super(Singleton,cls).__new__(cls)
return cls._instance
class MyClass(Singleton):
def __init__(self,name):
if name:
self.name = name
a = MyClass('a')
print(a)
print(a.name)
b = MyClass('b')
print(b)
print(b.name)
print(a)
print(a.name)
输出:
实例参考:https://blog.csdn.net/qq_30815237/article/details/89320071
常见实现单例的方式有懒汉式和饿汉式
懒汉式,第一次调用才初始化,避免内存浪费。
饿汉式,类加载时就初始化,浪费内存。单例模式——饿汉模式
from:https://www.runoob.com/design-pattern/singleton-pattern.html
2、工厂模式
概念
定义一个创建对象的接口,但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。
属于创建型模式,它提供了一种创建对象的最佳方式。目标是当直接创建对象(在Python中是通过__init__()函数实现的)不太方便时,提供更好的方式。
在工厂设计模式中,客户端①可以请求一个对象,而无需知道这个对象来自哪里;也就是,使用哪个类来生成这个对象。工厂背后的思想是简化对象的创建。与客户端自己基于类实例化直接创建对象相比,基于一个中心化函数来实现,更易于追踪创建了哪些对象。通过将创建对象的代码和使用对象的代码解耦,工厂能够降低应用维护的复杂度。
工厂方法创建对象时,我们并没有与某个特定类耦合/绑定到一起,而只是通过调用某个函数来提供关于我们想要什么的部分信息。这意味着修改这个函数比较容易,不需要同时修改使用这个函数的代码。
工厂通常有两种形式:一种是工厂方法(Factory Method),它是一个方法(或以Python术语来说,是一个函数),对不同的输入参数返回不同的对象;第二种是抽象工厂,它是一组用于创建一系列相关事物对象的工厂方法。
在工厂方法(简单工厂)模式中,我们执行单个函数,传入一个参数(提供信息表明我们想要什么),但并不要求知道任何关于对象如何实现以及对象来自哪里的细节。
一个例子:
- 我们有一个基类Person ,包涵获取名字,性别的方法 。有两个子类male 和female,可以打招呼。还有一个工厂类。
- 工厂类有一个方法名getPerson有两个输入参数,名字和性别。
- 用户使用工厂类,通过调用getPerson方法。
实现一个工厂方法,通过输入物料,然后产出不同的产品类。在程序运行期间,用户传递性别给工厂,工厂创建一个与性别有关的对象。因此工厂类在运行期,决定了哪个对象应该被创建。
class Person:
def __init__(self):
self.name = None
self.gender = None
def getName(self):
return self.name
def getGender(self):
return self.gender
class Male(Person):
def __init__(self, name):
print "Hello Mr." + name
class Female(Person):
def __init__(self, name):
print "Hello Miss." + name
class Factory:
def getPerson(self, name, gender):
if gender == ‘M':
return Male(name)
if gender == 'F':
return Female(name)
if __name__ == '__main__':
factory = Factory()
person = factory.getPerson("Chetan", "M")
结果:
from :https://blog.csdn.net/Dear_Mr_Wang/article/details/70146841
3、建造者模式
将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。建造者模式将所有细节都交由子类实现。
需求,画人物,要求画一个人的头,左手,右手,左脚,右脚和身体,画一个瘦子,一个胖子
不使用设计模式
if __name__=='__name__':
print '画左手'
print '画右手'
print '画左脚'
print '画右脚'
print '画胖身体'
print '画左手'
print '画右手'
print '画左脚'
print '画右脚'
print '画瘦身体'
这样写的缺点每画一个人,都要依次得画他的六个部位,这些部位有一些事可以重用的,所以调用起来会比较繁琐,而且客户调用的时候可能会忘记画其中的一个部位,所以容易出错。
建造一个抽象的类Builder,声明画六个部位的方法,每画一种人,就新建一个继承Builder的类,这样新建的类就必须要实现Builder的所有方法,这里主要运用了抽象方法的特性,父类定义了几个抽象的方法,子类必须要实现这些方法,否则就报错,这里解决了会漏画一个部位的问题。建造一个指挥者类Director,输入一个Builder类,定义一个draw的方法,把画这六个部位的方法调用都放在里面,这样调用起来就不会繁琐了。
- Python本身不提供抽象类和接口机制,要想实现抽象类,可以借助abc模块。abc是Abstract Base Class的缩写。
- 被@abstractmethod装饰为抽象方法后,该方法不能被实例化;除非子类实现了基类的抽象方法,所以能实例化。
#encoding=utf-8
from abc import ABCMeta, abstractmethod
class Builder():
__metaclass__ = ABCMeta
@abstractmethod
def draw_left_arm(self):
pass
@abstractmethod
def draw_right_arm(self):
pass
@abstractmethod
def draw_left_foot(self):
pass
@abstractmethod
def draw_right_foot(self):
pass
@abstractmethod
def draw_head(self):
pass
@abstractmethod
def draw_body(self):
pass
class Thin(Builder):#继承抽象类,必须实现其中定义的方法
def draw_left_arm(self):
print '画左手'
def draw_right_arm(self):
print '画右手'
def draw_left_foot(self):
print '画左脚'
def draw_right_foot(self):
print '画右脚'
def draw_head(self):
print '画头'
def draw_body(self):
print '画瘦身体'
class Fat(Builder):
def draw_left_arm(self):
print '画左手'
def draw_right_arm(self):
print '画右手'
def draw_left_foot(self):
print '画左脚'
def draw_right_foot(self):
print '画右脚'
def draw_head(self):
print '画头'
def draw_body(self):
print '画胖身体'
class Director():
def __init__(self, person):
self.person=person
def draw(self):
self.person.draw_left_arm()
self.person.draw_right_arm()
self.person.draw_left_foot()
self.person.draw_right_foot()
self.person.draw_head()
self.person.draw_body()
if __name__=='__main__':
thin=Thin()
fat=Fat()
director_thin=Director(thin)
director_thin.draw()
director_fat=Director(fat)
director_fat.draw()
结果:
建造者模式用于将一个复杂的对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
from:https://www.cnblogs.com/Xjng/p/4038547.html