python学习(28) 浅谈可变对象的单例模式设计

python开发,有时候需要设计单例模式保证操作的唯一性和安全性。理论上python语言底层实现和C/C++不同,python采取的是引用模式,当一个对象是可变对象,对其修改不会更改引用的指向,当一个对象是不可修改对象,对其修改会改变引用指向。

可变对象和不可变对象

不可变对象

该对象所指向的内存中的值不能被改变。当改变某个变量时候,由于其所指的值不能被改变,相当于把原来的值复制一份后再改变,这会开辟一个新的地址,变量再指向这个新的地址。

可变对象

该对象所指向的内存中的值可以被改变。变量(准确的说是引用)改变后,实际上是其所指的值直接发生改变,并没有发生复制行为,也没有开辟新的出地址,通俗点说就是原地改变。

python 中的可变对象和不可变对象

Python中,数值类型(int和float)、字符串str、元组tuple都是不可变类型。
而列表list、字典dict、集合set,以及开发人员自己定义的类是可变类型

python 和C/C++ 内存分配差异

1
2
3
4
5
6
a = 2
b = 2
c = a + 0
c += 0
print(id(a), id(b), id(2)) # id都相同
print(c is b) #True

python 中变量a,b,c都是常量2的引用,所以他们的地址空间都相同。在C/C++中,a,b,c是三个变量,每个变量地址都不一样,这一点大家在学习语言时要注意,这算是python的特性吧。同样的道理,字符串也是一样的

1
2
3
4
5
astr = 'good'
bstr = 'good'
cstr = astr + ''
print(cstr is bstr) # True
print(id(astr), id(bstr), id('good')) # 三个id相同

字符串也是不可变对象,所以astr,bstr,cstr指向的都’good’所在空间
如果修改astr,则astr指向改变了

1
2
3
4
astr = 'good'
print(id(astr))
astr += 'aa'
print(id(astr)) # id和上面的不一样

因为str是不可变对象,当修改它的值后变为’goodaa’,那么astr指向的地址也改变为’goodaa’所在地址。id(astr)和之前的不一样了。

1
2
3
4
5
lis = [1, 2, 3]
lis2 = [1, 2, 3]
# 虽然它们的内容一样,但是它们指向的是不同的内存地址
print(lis is lis2)
print(id(lis), id(lis2), id([1, 2, 3])) # 三个id都不同

虽然lis和lis2内容一样,但是可变对象都会单独开辟空间,所以上边三个id打印结果都不一样。

1
2
3
4
5
6
7
8
alist = [1, 2, 3]
# alist实际上是对对象的引用,blist = alist即引用的传递,现在两个引用都指向了同一个对象(地址)
blist = alist
print(id(alist), id(blist)) # id一样
# 所以其中一个变化,会影响到另外一个
blist.append(4)
print(alist) # 改变blist, alist也变成了[1 ,2 ,3 4]
print(id(alist), id(blist)) # id一样,和上面值没有改变时候的id也一样

blist赋值为alist,这两个指向同一个地址,当修改blist时,alist也改变了,所以打印两个id都是一样的。一般我们自己定义的类也是可变对象,我们想做的是通过设计一个单例类实现统一的控制,这样便于管理,比如网络模块,比如数据库处理模块等等。下面浅谈三种单例模式设计

python 单例模式设计

方法一:使用装饰器

装饰器维护一个字典对象instances,缓存了所有单例类,只要单例不存在则创建,已经存在直接返回该实例对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def singleton(cls):
instances = {}
def wrapper(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return wrapper

@singleton
class Foo(object):
pass
foo1 = Foo()
foo2 = Foo()
print foo1 is foo2

singleton函数中定义了instances字典,当使用它作为装饰器装饰Foo后instances也会被缓存在闭包环境中,第一次使用Foo()后,instances就回被设置为instances[Foo]=Foo(),这样根据类名就可以区分是否被初始化过,从而实现单例模式

方法二:使用基类

__new__是真正创建实例对象的方法,所以重写基类的__new__方法,以此来保证创建对象的时候只生成一个实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Singleton(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls, '_instance'):
cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
return cls._instance


class Foo(Singleton):
pass

foo1 = Foo()
foo2 = Foo()

print foo1 is foo2 # True

__new__在一个类构造实例对象时会调用,所以通过判断hasattr,是否含有某个属性,即可实现单例模式。
super(Singleton,cls)调用的是Singleton的基类。我目前用的是这种方式实现的单例,用作网络和数据库管理。

方法三:使用元类

元类(参考:深刻理解Python中的元类)是用于创建类对象的类,类对象创建实例对象时一定会调用__call__方法,因此在调用__call__时候保证始终只创建一个实例即可,type是python中的一个元类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Singleton(type):
def __call__(cls, *args, **kwargs):
if not hasattr(cls, '_instance'):
cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
return cls._instance


class Foo(object):
__metaclass__ = Singleton


foo1 = Foo()
foo2 = Foo()

print foo1 is foo2 # True

这种方式和new类似,都是通过系统级的函数__call__进行控制。通过在类中设置元类从而实现单例控制。

到目前为止,单例模式介绍完毕,感谢关注我的公众号

wxgzh.jpg