Python 对象的引用计数和拷贝

dsfsfs

Python 对象的引用计数和拷贝
　　
　　Python是一种面向对象的语言，包括变量、函数、类、模块等等一切皆对象。
　　在python中，每个对象有以下三个属性：
　　1、id，每个对象都有一个唯一的身份标识自己，可通过内建函数id(obj)查看。
　　2、type，对象的类型决定了该对象可以保存什么类型的值，可用内建函数type(obj)查看；
　　3、value，即对象的值。
　　
　　下面是一个例子：



>>> str = "hello world"
>>> type(str)
<type 'str'>
>>> id(str)
139840619053776
>>> str2="hello world"
>>> id(str2)
139840619053888
>>> str == str2
True
>>> str is str2
False
>>>
　　注意：id()函数返回一个数字，不同的对象的id值不一样，即使他们值一样。
　　同时也可以看出，关系运算符 "==" 比较的是两个对象的值是否相等，而 is 比较的是两个变量是否为同一个对象（或者说指向同一块内存）。
　　
　　还有一个内建函数cmp，也可用于比较两个对象的值，它返回的是一个int值，例如：



>>> cmp("abc", "bcd")
-1
>>> cmp(7,7)         
0
>>> cmp(7,9)
-1
>>> cmp(19,9)
1
　　
　　再来看下面这个有趣的现象：



>>> a = [4]
>>> b = [4]
>>> a is b
False
>>> a = 1
>>> b = 1
>>> a is b
True
　　可见，对两个变量赋予相同的值，它们有可能是同一个对象（对不可变对象而言，可以节省内存），也可能是两个不同的对象，这可能取决于对象的类型（type）。
　　
　　

　　Python中使用了智能指针的技术（与Java中的垃圾回收GC机制类似），每个变量都和指向对象（object）的指针相关联，每一个object都有一个reference counter（引用计数器）记住有多少个变量和这个object绑定（bind）。每次bind，reference count都加1，每次删除bind关系，都减少1，只有reference counter变成0的时候才真正删除对象。
　　以下情况时，对象的引用计数增加：

• 对象被创建；
  
• 另外的别名被创建；
  
• 作为参数传递给函数；
  
• 成为容器对象的一个元素；
  

　　以下情况时，对象的引用计数减少：

• 一个本地引用离开其作用范围，比如函数结束时，所有局部变量都被自动销毁；
  
• 用del语句显式删除一个变量（同时该变量从name space中删除）；
  
• 对象的一个别名被赋值给其他对象；
  
• 对象被移出一个容器对象时；
  
• 容器对象本身的引用计数变成0；
  

　　
　　例如：



x = 3.14         　　　　　　　　# 创建的3.14 这个对象的引用计数为1
y = x        　　　　　　　　　　# 创建对象别名，对象”3.14”的引用计数为2
myList = [123, x, ‘xyz’]      # 成为容器的一个元素，对象”3.14”的引用计数为3
y = 123        　　　　　　　　 # 对象别名bind到其它对象，对象”3.14”的引用计数为2
del myList        　　　　　　  # 容器被删除，对象”3.14”的引用计数为1
　　注意：解释器跟踪对象的引用计数，而垃圾收集器负责释放内存。当一个对象的引用计数变为0，解释器会暂停，释放掉这个对象和仅有这个对象可访问的其他对象。这里，还要特别注意循环引用的情况。
　　
　　

　　
　　Python中，常用对象的一些访问模型：

数据类型	存储模型	更新模型	访问模型
数字	标量	不可更改	直接访问
字符串	标量	不可更改	顺序访问
列表	容器	可更改	顺序访问
元组	容器	不可更改	顺序访问
字典	容器	可更改	映射访问

　　一个很重要的区别：数字、字符串、元组是不可变对象，列表和字典是可变对象。
　　对于不可改变类型来说，无法通过变量更新对象的值，例如：



>>> x = 12
>>> id(x)
8483376
>>> x = 45
>>> id(x)
8484576
　　这里，表面上看变量x的值被更新了，其实是12这个数字对象被销毁了，然后创建了一个新的数字对象45，变量x被bind到这个新对象上。
　　字符串对象也是不可变类型，不可变对象作为左值时，必须是一个完整的对象。例如：



>>> s = 'hello world\n'
>>> s[3] = 'x'                 
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> s = '%sL%s' %(s[:3],s[4:])
>>> s
'helLo world\n'
>>>
　　
　　另外一个有趣的区别是，不可变对象的方法通常有返回值，而可变对象的方法通常返回None，比如



>>> s = 'abc'
>>> ret = s.upper()
>>> ret
'ABC'
>>> l = [1, 2]
>>> ret = l.append(3)
>>> ret
>>> l
[1, 2, 3]
　　这是因为不可变对象因为对象自身无法修改，因此其方法只能返回一个新对象；而可变对象直接原地修改原对象。
　　
　　

　　
　　Python中，序列类型对象（比如list）的赋值操作只是一种简单的浅拷贝，例如：



>>> a = [1,2,3]   
>>> b = a
>>> id(a)      
139972192906488
>>> id(b)
139972192906488
>>> b[2] = "hello"
>>> a
[1, 2, 'hello']
　　可见，列表a和列表b指向对一个对象，修改列表b之后，列表a也相应的受到影响了。
　　浅拷贝的其它实现方式：



import copy
a = [1,['joy', 1000],3,4]
b = copy.copy(a)            # 浅拷贝
c = a[:]                    # 完全切片操作
d = list(a)                 # 工厂函数
print id(a),id(b),id(c),id(d)
b[1][0] = 'name'         
print [id(item) for item in a]
print [id(item) for item in b]
print [id(item) for item in c]
print [id(item) for item in d]
print a
print b
print c
print d
　　运行结果：



139954864753840 139954864851208 139954864849552 139954864849624
[30569272, 139954864710504, 30569224, 30569200]
[30569272, 139954864710504, 30569224, 30569200]
[30569272, 139954864710504, 30569224, 30569200]
[30569272, 139954864710504, 30569224, 30569200]
[1, ['name', 1000], 3, 4]
[1, ['name', 1000], 3, 4]
[1, ['name', 1000], 3, 4]
[1, ['name', 1000], 3, 4]
　　可见，虽然a、b、c、d 这4个对象的id各不相同，但它们的元素id完全一样，也就是这4个对象指向的其实都是同一块内存，通过其中任何一个对象对列表所作的修改，对其他3个对象都是可见的。
　　
　　如果我们需要复制一份序列类型的对象，并且对副本进行操作而不影响原来的序列，通常就需要进行深拷贝了。



import copy
a = [1,['joy', 1000],3,4]
b = copy.deepcopy(a)        # 深拷贝
c = a[:]                    # 完全切片操作
d = list(a)                 # 工厂函数
print id(a),id(b),id(c),id(d)
b[1][0] = 'name'         
print [id(item) for item in a]
print [id(item) for item in b]
print [id(item) for item in c]
print [id(item) for item in d]
print a
print b
print c
print d
　　运行结果：



139880002817200 139880002912984 139880002914136 139880002914928
[37511992, 139880002773864, 37511944, 37511920]
[37511992, 139880002914640, 37511944, 37511920]
[37511992, 139880002773864, 37511944, 37511920]
[37511992, 139880002773864, 37511944, 37511920]
[1, ['joy', 1000], 3, 4]
[1, ['name', 1000], 3, 4]
[1, ['joy', 1000], 3, 4]
[1, ['joy', 1000], 3, 4]
　　可见，对象b的可变元素与原对象中的元素具有不同的id，因此对b的可变元素的修改，不影响原始的对象。
　　
　　对字典也是类似的，浅拷贝如下：



>>> dict = {"name":"chen", "age":100}
>>> dict2 = dict
>>> dict2["name"] = "Lau"
>>> dict
{'age': 100, 'name': 'Lau'}
　　
　　利用字典的copy方法，可以实现深拷贝，例如：



>>> dict = {"name":"chen", "age":100}
>>> dict2 = dict.copy()
>>> dict2
{'age': 100, 'name': 'chen'}
>>> dict2["name"] = "Lau"
>>> dict
{'age': 100, 'name': 'chen'}
>>> dict2
{'age': 100, 'name': 'Lau'}