python的设计模式_python 设计模式

设计模式

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

0、接口

定义:一种特殊的类,声明了若干方法,要求继承该接口的类必须实现这种方法，作用:限制继承接口的类的方法的名称及调用方式,隐藏了类的内部实现

1、单例模式

​ 单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。
定义: 保证一个类只有一个实例,并提供一个访问它的全局访问点
适用场景:当一个类只能有一个实例，而客户可以从一个众所周知的访问点访问它时。
优点
1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。
比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。

方法一：使用模块

实现方法：将需要实现的单例功能放到一个.py 文件中

实现原理：Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。

mysingleton.py
class Singleton(object):
    def foo(self):
        pass
singleton = Singleton()
1
2
3
4
5

将上面的代码保存在文件 mysingleton.py 中，要使用时，直接在其他文件中导入此文件中的对象，这个对象即是单例模式的对象

from a import singleton
1

方法二、装饰器实现

def Singleton(cls):
    _instance = {}
    def _singleton(*args, **kargs):
        if cls not in _instance:#判断该实例是否存在，存在就直接返回，不存在就创建        
            _instance[cls] = cls(*args, **kargs)
        return _instance[cls]
    return _singleton
 
@Singleton
class A(object):
    a = 1
    def __init__(self, x=0):
        self.x = x

# a1 = A(2)
a2 = A(3)
# 输出：{<class '__main__.A'>: <__main__.A object at 0x7fb9af751af0>}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

方法三、基于__new__方法

我们知道，当我们实例化一个对象时，是先执行了类的__new__方法（我们没写时，默认调用object.new），实例化对象；然后再执行类的__init__方法，对这个对象进行初始化，所有我们可以基于这个，实现单例模式

个人最初常用的是重写__new__方法的方式，但是用重写类中的__new__方法，在多次创建对象时，尽管返回的都是同一个对象，但是每次执行创建对象语句时，内部的__init__方法都会被自动调用，而在某些应用场景，可能存在初始化方法只能允许运行一次的需求，这时这种实现单例的方式并不可取

class Download(object):
    instance = None

    def __init__(self):
        print("__init__")
    
    def __new__(cls, *args, **kwargs):
        if cls.instance is None:
            cls.instance = super().__new__(cls)
        return cls.instance

object1 = Download()
object2 = Download()
print(object1)
print(object2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果，可以看到初始化方法多次执行了：

__init__
__init__
<__main__.Download object at 0x10268a748>
<__main__.Download object at 0x10268a748>
1
2
3
4

原文链接：https://blog.csdn.net/weixin_43783714/article/details/103352436

init 方法通常用在初始化一个类实例时候，但其实它不是实例化一个类的时候第一个被调用 的方法。当使用 Student(id, name) 这样的表达式来实例化一个类时，最先被调用的方法 其实是 new 方法。

new方法接受的参数虽然也是和init一样，但init是在类实例创建之后调用，而 new方法正是创建这个类实例的方法。

new为对象分配空间，是内置的静态方法，new在内存中为对象分配了空间也返回了对象的引用，init获得了这个引用才初始化这个实例。

示例

一个非常简单的单例

class A:
 instance = None
 def __new__(cls, *args, **kwargs):
  if cls.instance is None:
   cls.instance = super().__new__(cls)
  return cls.instance
1
2
3
4
5
6

因为new方法是一个静态方法（也就是在定义的时候就没有cls参数），所以在这里要传入一个cls参数，而且这里的new你改造过了，所以要返回爸爸的new方法。

按造这个方法改造的单例怎么new都是同一个实例，但init仍然会被执行多次，也就是创建了几个对象就调用几次初始化方法。所以还要对init再进行一些判断。

class A:
 instance = None
 init_flag = False # 初始化标记
 
 def __new__(cls, *args, **kwargs):
  if cls.instance is None:
   cls.instance = super().__new__(cls)
  return cls.instance
 
 def __init__(self):
  if A.init_flag:
   return
  print('执行了初始化方法')
  A.init_flag = True
 
if __name__ == '__main__':
 a = A()
 b = A()
 print(a)
 print(b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2、工厂模式

概念

定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。属于创建型模式，它提供了一种创建对象的最佳方式。目标是当直接创建对象（在Python中是通过__init__()函数实现的）不太方便时，提供更好的方式。

在工厂设计模式中，客户端①可以请求一个对象，而无需知道这个对象来自哪里；也就是，使用哪个类来生成这个对象。工厂背后的思想是简化对象的创建。与客户端自己基于类实例化直接创建对象相比，基于一个中心化函数来实现，更易于追踪创建了哪些对象。

通过将创建对象的代码和使用对象的代码解耦，工厂能够降低应用维护的复杂度。

工厂方法创建对象时，我们并没有与某个特定类耦合/绑定到一起，而只是通过调用某个函数来提供关于我们想要什么的部分信息。这意味着修改这个函数比较容易，不需要同时修改使用这个函数的代码。

工厂通常有两种形式：

第一种是工厂方法（Factory Method），它是一个方法（或以Python术语来说，是一个函数），对不同的输入参数返回不同的对象；

第二种是抽象工厂，它是一组用于创建一系列相关事物对象的工厂方法。

两种形式的区别：

https://www.cnblogs.com/Zzbj/p/15778464.html
1

在工厂方法(简单工厂)模式中，我们执行单个函数，传入一个参数（提供信息表明我们想要什么），但并不要求知道任何关于对象如何实现以及对象来自哪里的细节。

一个例子：

我们有一个基类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")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

3、建造者模式

​ 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式将所有细节都交由子类实现。需求，画人物，要求画一个人的头，左手，右手，左脚，右脚和身体，画一个瘦子，一个胖子

不使用设计模式：

if __name__=='__name__':
    print '画左手'
    print '画右手'
    print '画左脚'
    print '画右脚'
    print '画胖身体'

    print '画左手'
    print '画右手'
    print '画左脚'
    print '画右脚'
    print '画瘦身体'
1
2
3
4
5
6
7
8
9
10
11
12

​ 这样写的缺点每画一个人，都要依次得画他的六个部位，这些部位有一些事可以重用的，所以调用起来会比较繁琐，而且客户调用的时候可能会忘记画其中的一个部位，所以容易出错。

​ 建造一个抽象的类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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

建造者模式用于将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。