首页 > 代码库 > Python 对象的引用计数和拷贝

Python 对象的引用计数和拷贝

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 == str2True>>> str is str2False>>> 

注意: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 bFalse>>> a = 1>>> b = 1>>> a is bTrue

可见,对两个变量赋予相同的值,它们有可能是同一个对象(对不可变对象而言,可以节省内存),也可能是两个不同的对象,这可能取决于对象的类型(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 这个对象的引用计数为1y = x                  # 创建对象别名,对象”3.14”的引用计数为2myList = [123, x, ‘xyz’]      # 成为容器的一个元素,对象”3.14”的引用计数为3y = 123                 # 对象别名bind到其它对象,对象”3.14”的引用计数为2del 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:]) >>> shelLo world\n>>> 

 

另外一个有趣的区别是,不可变对象的方法通常有返回值,而可变对象的方法通常返回None,比如

>>> s = abc>>> ret = s.upper()>>> retABC>>> 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 copya = [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 aprint bprint cprint 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 copya = [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 aprint bprint cprint 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}

 

Python 对象的引用计数和拷贝