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()

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

from a import singleton
方法二、装饰器实现
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>}
方法三、基于__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)

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

__init__
__init__
<__main__.Download object at 0x10268a748>
<__main__.Download object at 0x10268a748>

原文链接: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

因为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)

2、工厂模式

概念

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

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

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

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

工厂通常有两种形式:

第一种是工厂方法(Factory Method),它是一个方法(或以Python术语来说,是一个函数),对不同的输入参数返回不同的对象;

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

两种形式的区别:

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

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

一个例子:

我们有一个基类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")

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()

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

  • 6
    点赞
  • 46
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python中,设计模式是一种用于解决常见问题的可复用的解决方案。设计模式可以帮助我们更好地组织和管理代码,并提供一种结构化的方法来解决特定类型的问题。 以下是一些常见的Python设计模式: 1. 单例模式:确保一个类只有一个实例,并提供全局访问点。 ```python class Singleton: _instance = None def __new__(cls, *args, **kwargs): if not cls._instance: cls._instance = super().__new__(cls, *args, **kwargs) return cls._instance ``` 2. 工厂模式:通过一个工厂类来创建对象,而不是直接使用构造函数。 ```python class Shape: def draw(self): pass class Circle(Shape): def draw(self): print("Drawing a circle") class Rectangle(Shape): def draw(self): print("Drawing a rectangle") class ShapeFactory: def create_shape(self, shape_type): if shape_type == "circle": return Circle() elif shape_type == "rectangle": return Rectangle() else: raise ValueError("Invalid shape type") factory = ShapeFactory() circle = factory.create_shape("circle") circle.draw() # 输出:Drawing a circle ``` 3. 观察者模式:定义了一种一对多的依赖关系,当一个对象的状态发生变化时,所有依赖于它的对象都会收到通知并自动更新。 ```python class Subject: def __init__(self): self._observers = [] def attach(self, observer): self._observers.append(observer) def detach(self, observer): self._observers.remove(observer) def notify(self): for observer in self._observers: observer.update() class Observer: def update(self): pass class ConcreteObserver(Observer): def update(self): print("Received notification") subject = Subject() observer = ConcreteObserver() subject.attach(observer) subject.notify() # 输出:Received notification ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值