单例模式 

#步骤五：基于元类实现单例模式
# 单例：即单个实例，指的是同一个类实例化多次的结果指向同一个对象，用于节省内存空间
# 如果我们从配置文件中读取配置来进行实例化，在配置相同的情况下，就没必要重复产生对象浪费内存了
#settings.py文件内容如下
HOST='1.1.1.1'
PORT=3306

#方式一:定义一个类方法实现单例模式
import settings

class Mysql:
    __instance=None
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @classmethod
    def singleton(cls):
        if not cls.__instance:
            cls.__instance=cls(settings.HOST,settings.PORT)
        return cls.__instance


obj1=Mysql('1.1.1.2',3306)
obj2=Mysql('1.1.1.3',3307)
print(obj1 is obj2) #False

obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True



#方式二：定制元类实现单例模式
import settings

class Mymeta(type):
    def __init__(self,name,bases,dic): #定义类Mysql时就触发

        # 事先先从配置文件中取配置来造一个Mysql的实例出来
        self.__instance = object.__new__(self)  # 产生对象
        self.__init__(self.__instance, settings.HOST, settings.PORT)  # 初始化对象
        # 上述两步可以合成下面一步
        # self.__instance=super().__call__(*args,**kwargs)


        super().__init__(name,bases,dic)

    def __call__(self, *args, **kwargs): #Mysql(...)时触发
        if args or kwargs: # args或kwargs内有值
            obj=object.__new__(self)
            self.__init__(obj,*args,**kwargs)
            return obj

        return self.__instance




class Mysql(metaclass=Mymeta):
    def __init__(self,host,port):
        self.host=host
        self.port=port



obj1=Mysql() # 没有传值则默认从配置文件中读配置来实例化，所有的实例应该指向一个内存地址
obj2=Mysql()
obj3=Mysql()

print(obj1 is obj2 is obj3)

obj4=Mysql('1.1.1.4',3307)



#方式三:定义一个装饰器实现单例模式
import settings

def singleton(cls): #cls=Mysql
    _instance=cls(settings.HOST,settings.PORT)

    def wrapper(*args,**kwargs):
        if args or kwargs:
            obj=cls(*args,**kwargs)
            return obj
        return _instance

    return wrapper


@singleton # Mysql=singleton(Mysql)
class Mysql:
    def __init__(self,host,port):
        self.host=host
        self.port=port

obj1=Mysql()
obj2=Mysql()
obj3=Mysql()
print(obj1 is obj2 is obj3) #True

obj4=Mysql('1.1.1.3',3307)
obj5=Mysql('1.1.1.4',3308)
print(obj3 is obj4) #False

单例模式

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。

比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。

在 Python 中，我们可以用多种方法来实现单例模式：

（1）使用模块

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

（2）使用__new__方法

为了使类只能出现一个实例，我们可以使用 __new__ 来控制实例的创建过程，代码如下：

class SingleTog(object):
    __instance = None

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
            # cls.__instance = super(SingleTog, cls).__new__(*args, **kwargs)  # 或者这么写
        return cls.__instance

    def __init__(self, name):
        self.name = name


s1 = SingleTog("ggg")
s2 = SingleTog("hhh")
print(s1 is s2)  # True
print(s1.name)  # hhh
print(s2.name)  # hhh self赋值时的覆盖

 

（3）定义一个装饰器实现

def single_tog(cls):
    _instance = {}

    def inner(*args, **kwargs):
        if cls not in _instance:
            _instance[cls] = cls(*args, **kwargs)
        return _instance[cls]

    return inner


@single_tog  # Foo = single_tog(Foo)
class Foo:

    def __init__(self, name):
        self.name = name


f1 = Foo("ggg")
f2 = Foo("hhh")
print(f1 is f2)  # True
print(f1.name)  # ggg
print(f2.name)  # ggg
def single_tog(cls):
    _instance = None

    def inner(*args, **kwargs):
        nonlocal _instance
        if not _instance:
            _instance = cls(*args, **kwargs)
        return _instance

    return inner


@single_tog  # Foo = single_tog(Foo)
class Foo:
    def __init__(self, name):
        self.name = name


f1 = Foo("ggg")
f2 = Foo("hhh")
print(id(f1))
print(id(f2))
print(f1.name)
print(f2.name)
我还有一种写法

（4）共享属性

        所谓单例模式就是所有的引用（实例，对象）拥有相同的属性和方法，同一个类的实例天生都会有相同的方法，那么我们只需要保证同一个类所产生的实例都具有相同的属性。所有的实例共享属性的最简单直接的办法就是共享__dict__属性指向；

class SingTog(object):
    _state = {}

    def __new__(cls, *args, **kwargs):
        obj = object.__new__(cls)
        obj.__dict__ = cls._state
        return obj


class Foo(SingTog):  # 继承我们的单例类
    a = 1

    def __init__(self, b):
        self.b = b


f1 = Foo(123)
f2 = Foo(456)
print(id(f1))  # id虽然不一样，但是做到了所有实例的属性和方法都一样
print(id(f2))
print(f1.a)  # 1
print(f2.a)  # 1
print(f1.b)  # 456
print(f2.b)  # 456
f1.a = 222
print(f1.a)  # 222
print(f2.a)  # 222

（5）使用元类（metaclass）

 

 

posted @ 2018-08-04 11:22  Mr.GLH  阅读(531)  评论(0)  编辑  收藏  举报
Top↑