Python常见设计模式

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。

0:接口

　定义:一种特殊的类,声明了若干方法,要求继承该接口的类必须实现这种方法

作用:限制继承接口的类的方法的名称及调用方式,隐藏了类的内部实现

from abc import ABCMeta,abstractmethodclass Payment(metaclass=ABCMeta):@abstractmethod#定义抽象方法的关键字def pay(self,money):pass# @abstractmethod# def pay(self,money):#     raise NotImplementedErrorclass 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._instanceclass MyClass(Singleton):def __init__(self,name):if name:self.name = namea = 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 = Noneself.gender = Nonedef getName(self):return self.namedef getGender(self):return self.genderclass Male(Person):def __init__(self, name):print "Hello Mr." + nameclass Female(Person):def __init__(self, name):print "Hello Miss." + nameclass 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, abstractmethodclass Builder():__metaclass__ = ABCMeta@abstractmethoddef draw_left_arm(self):pass@abstractmethoddef draw_right_arm(self):pass@abstractmethoddef draw_left_foot(self):pass@abstractmethoddef draw_right_foot(self):pass@abstractmethoddef draw_head(self):pass@abstractmethoddef draw_body(self):passclass 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=persondef 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