二十二.面向对象 单例模式

一. 单例模式

单例模式：基于某种方法实例化多次得到实例是同一个
当实例化多次得到的对象中存放的属性都一样的情况，应该将多个对象指向同一个内存，即同一个实例
减少内存占用

类内部定义静态方法实现单例模式

class Da(object):
    def __init__(self,age,name):
        self.age=age
        self.name=name
    def aa(self):
        print("单例模式哈哈哈哈")
v=None
while True:
    if v:
        v.aa()
    else:
        v = Da("555", "张三")
        v.aa()

class People():
    __instance = None
    @classmethod
    def from_conf(cls):
        if cls.__instance:
               return  cls.__instance
        else:
            cls.__instance=People()
            return  cls.__instance
a1=People.from_conf()
print(a1)

a1=People.from_conf()
print(a1)
a1=People.from_conf()
print(a1)

print("*****************************************************************88")

class People():
    __instance = None
    @classmethod
    def from_conf(cls):
        if cls.__instance:
            return cls.__instance

        cls.__instance = cls()
        return cls.__instance

aa=People.from_conf()
print(aa)

a2=People.from_conf()
print(a2)

装饰器实现单例模式

#
# 代码分析：第1行，创建外层函数singleton，可以传入类
# 　　　　　第2行，创建一个instances字典用来保存单例
# 　　　　   第3行，创建一个内层函数来获得单例
# 　　　　   第4，5，6行， 判断instances字典中是否含有单例，如果没有就创建单例并保存到instances字典中，然后返回该单例
# 　　　　   第7行， 返回内层函数get_instance


 # 使用装饰器实现单例模式
# 可以看出，虽然进行了两次实例化，但是仍然为同一个实例。
def singleton(cls, *args, **kwargs):
    instance = {}
    def _instance():
        if cls not in instance:
            instance[cls] = cls(*args, *kwargs)
        return instance[cls]
    return _instance
@singleton
class Test_singleton:
    def __init__(self):
        self.num = 0
    def add(self):
        self.num = 99
ts1 = Test_singleton()
ts2 = Test_singleton()
ts3 = Test_singleton()
print(ts1)
print(ts2)
print(ts3)
print(ts3 is  ts1)
print(id(ts1))
print(id(ts2))

# <__main__.Test_singleton object at 0x0000017C71418F60>
# <__main__.Test_singleton object at 0x0000017C71418F60>
# <__main__.Test_singleton object at 0x0000017C71418F60>
# True
# 1412705718112
# 1412705718112


print("***********************************************************************888")


# 没有实现单例模式 实例化一下就产生有一个内存空间
class Test:
    def __init__(self):
        self.num = 0
    def add(self):
        self.num = 99

ts1=Test()
ts2=Test()
ts3=Test()
print(ts1)
print(ts2)
print(ts3)
print(ts3 is  ts1)


# <__main__.Test object at 0x0000017C71422048>
# <__main__.Test object at 0x0000017C71422080>
# <__main__.Test object at 0x0000017C714220B8>
# False

 

#
# 代码分析：第1行，创建外层函数singleton，可以传入类
# 　　　　　第2行，创建一个instances字典用来保存单例
# 　　　　   第3行，创建一个内层函数来获得单例
# 　　　　   第4，5，6行， 判断instances字典中是否含有单例，如果没有就创建单例并保存到instances字典中，然后返回该单例
# 　　　　   第7行， 返回内层函数get_instance


 # 使用装饰器实现单例模式
# 可以看出，虽然进行了两次实例化，但是仍然为同一个实例。
def singleton(cls,*args,**kwargs):
    instance = {}
    def _instance(*args, **kwargs):
        if cls not in instance:
            instance[cls] = cls(*args, *kwargs)
        return instance[cls]
    return _instance
@singleton
class Test:
    def __init__(self,aa,name):
        self.aa=aa
        self.name=name
ts1 = Test(666,"李四")
ts2 = Test(333,"王五")
print(ts1)
print(ts2)
print(ts1 is  ts2)
print(id(ts1))
print(id(ts2))
# <__main__.Test object at 0x000001FED67C88D0>
# <__main__.Test object at 0x000001FED67C88D0>
# True
# 2194031806672
# 2194031806672
print(ts1.aa)
print(ts2.aa)

print(ts1.name)
print(ts2.name)
#
# 666
# 666
# 李四
# 李四

 

 

 

 

class Person(object):

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


alex=Person("alex",33)
egon=Person("egon",32)

单例模式




单例模式方式1 ：__new__

class Singleton(object):

    _instance = None
    def __new__(cls, *args, **kw):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)
        return cls._instance

class MyClass(Singleton):
    a = 1



mc1=MyClass()

mc2=MyClass()

mc3=MyClass()


print(id(mc1))
print(id(mc2))
print(id(mc3))

 

 

单例模式 模块方式

 mysingleton.py


class My_Singleton(object):
    def foo(self):
        print("foo.....")


my_singleton = My_Singleton()

func.py


from mysingleton import my_singleton

def bar():
    print(id(my_singleton))


import time

main.py 执行文件

from mysingleton import my_singleton,My_Singleton

my_singleton.foo()

print(id(my_singleton))


思考1
from mysingleton import my_singleton as my_singleton_new

print(id(my_singleton_new))
print(id(my_singleton))

思考2
import func

func.bar()

思考3

from mysingleton import my_singleton,My_Singleton

ms1=My_Singleton()

from mysingleton import my_singleton,My_Singleton

ms2=My_Singleton()

print(id(ms1))
print(id(ms2))

执行结果

foo.....
47583824
47583824
47583824
47583824
46795536
46795632