设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
设计模式六大原则：
1.单一职责原则：
一个类只负责一项职责。
2.里氏替换原则：
所有引用基类（父类）的地方必须能透明的使用其子类的对象。
3.依赖倒置原则：
高层模块不应该依赖底层模块，二者都应该依赖其抽象，抽象不应该依赖细节，细节应该依赖抽象。
4.接口隔离原则：
客户端不应该依赖它不需要的接口，一个类对另一个类的依赖，应该建立在最小的接口上。
5.迪米特法则：
一个对象应该对其他对象保持最少的了解，尽量降低类与类之间的耦合。
6.开闭原则：
一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。
分类
创建型模式
主要目的：创建对象
共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式
主要目的：对象的组成和对象的关系
共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式
主要目的：对象的行为，对象能做什么
共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
#定义伊兰特车类
classYilanteCar(object):
#定义车的方法
defmove(self):
print("---伊兰特在移动---")
defstop(self):
print("---伊兰特停车---")
#定义索纳塔车类
classSuonataCar(object):
#定义车的方法
defmove(self):
print("---索纳塔在移动---")
defstop(self):
print("---索纳塔停车---")
#定义一个生产汽车的工厂，让其根据具体的订单生产车
classCarFactory(object):
defcreateCar(self,typeName):
iftypeName =="伊兰特":
car = YilanteCar()
eliftypeName =="索纳塔":
car = SuonataCar()
returncar
#定义一个销售北京现代车的店类
classCarStore(object):
def__init__(self):
#设置4s店的指定生产汽车的工厂
self.carFactory = CarFactory()
deforder(self, typeName):
#让工厂根据类型，生产一辆汽车
car=self.carFactory.createCar(typeName)
returncar
o1 = CarStore()
o1.order('伊兰特').move()
o1.order('伊兰特').stop()
结果如下：
把生产环节重新创建了一个类，这确实比较像一种编程习惯，此种解决方式被称为简单工厂模式。
在创建对象比较简单的时候，我们直接在主方法中做了，但是很多时候，创建对象需要一些初始化的操作，或者业务逻辑的处理。也就是说，有时候创建一个对象会做比较复杂的操作，这个时候，如果所有对象的创建操作都放在主方法中，就不合适了，怎么解决呢？使用简单工厂模式
先来看看它的组成：
工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
具体产品角色：工厂类所创建的对象就是此角色的实例。
简单工厂的优点和缺点
对象创建比较复杂的时候，可以考虑使用简单工厂
优点：
在简单工厂中主函数或者客户端不再负责对象的创建，而是把这个责任交给工厂类，主函数或者客户端在使用对象的时候只从工厂中调用就行了，从而明确了各个类的职责，符合单一职责原则）
缺点
由于这个工厂类负责所有对象的创建，那么当子类增多时，我们就需要去修改工厂类的代码，这样呢，就违反了一个原则：开闭原则
如何保证开闭原则？可以使用工厂方法模式。
工厂方法模块组成：
抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
抽象产品角色：它是具体产品继承的父类或者是实现的接口。
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。
代码如下：
#抽象产品角色
classCar():
defcarMove(self):
pass
defcarstop(self):
pass
#具体产品角色
classSuonataCar():
defsuonataMove(self):
print('索纳塔正在运行.........')
defsuonataStop(self):
print('索纳塔已停止...........')
#具体产品角色
classYilanteCar():
defyilanteMove(self):
print('伊兰特正在运行.........')
defyilanteStop(self):
print('伊兰特已停止...........')
#工厂父类：抽象工厂角色
classCarFactory():
defcreatCar(self):
pass
#工厂子类：具体工厂角色
classYilanteCarFactory():
defcreatCar(self):
returnYilanteCar()
#工厂子类：具体工厂角色
classSuonataCarFactory():
defcreatCar(self):
returnSuonataCar()
#主函数，程序开始
f1 = YilanteCarFactory()
car1 = f1.creatCar()
car1.yilanteMove()
car1.yilanteStop()
f2 =SuonataCarFactory()
car2 = f2.creatCar()
car2.suonataMove()
car2.suonataStop()
结果如下：
解决了简单工厂违反的开闭原则，但是如果需要增加一个具体产品类角色，需要添加这个类和相对于的工厂类，代码量过大。
__new__()和__init__()
classA():
def__init__(self):
print('....__init__....')
print(self)
print(id(self))
def__new__(cls):
print('....__new__....')
print(cls)
print(id(cls))
ret =object.__new__(cls)
print(ret)
print(id(ret))
returnret
A()
结果如下：
__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例
__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值。
单例设计模式
举个常见的单例模式例子，我们日常使用的电脑上都有一个回收站，在整个操作系统中，回收站只能有一个实例，整个系统都使用这个唯一的实例，而且回收站自行提供自己的实例。因此回收站是单例模式的应用。
确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，单例模式是一种对象创建型模式。
只调用一次__new__():
class Singleton(object):
__instance = None
def __new__(cls):
if cls.__instance==None:
cls.__instance = object.__new__(cls)
return cls.__instance
wangcai = Singleton()
xiaoqiang = Singleton()
print(wangcai==xiaoqiang)
print(id(wangcai))
print(id(xiaoqiang))
结果如下：
只调用一次__init__()和__new__()：
class Singleton(object):
#表示对象是否被创建 None:没有，其它：已经创建
__instance = None
#表示是否是第一次调用init,False:不是第一次 True:是第一次
__first_init = True
def __init__(self,name):
if Singleton.__first_init:
self.name = name
Singleton.__first_init = False
def __new__(cls,name):
if cls.__instance==None:
cls.__instance = object.__new__(cls)
return cls.__instance
wangcai = Singleton('旺财')
xiaoqiang = Singleton('小强')
print(wangcai==xiaoqiang)
print(id(wangcai))
print(id(xiaoqiang))
结果如下：
