Python基础系列讲解—动态类型语言的特点-原创手记-慕课网

前言

在C语言中变量所分配到的地址是内存空间中一个固定的位置，当我们改变变量值时，对应内存空间中的值也相应改变。在Python中变量存储的机制是完全不一样的，当给一个变量赋值时首先解释器会给这个值分配内存空间，然后将变量指向这个值的地址，那么当我们改变变量值的时候解释器又会给新的值分配另一个内存空间，再将变量指向这个新值的地址，所以和C语言相比，在Python中改变的是变量所指向的地址，而内存空间中的值是固定不变的。

例程介绍

我们可以通过id方法查看变量的内存地址的方式来进行验证。以下先以Python的int类型为例，可以看到执行 i += 1 后，变量i的内存地址会发生变化，事实上 i += 1 并不是在原有变量i的地址上加1,而是重新创建一个值为6的int对象，变量i则引用了这个新的对象，因此当变量i和变量j的值相同时会指向同个内存地址。同样以Python的float 类型为例也验证了这个变量存储管理的机制。

#int 
i = 5
print "i ---> ",i
print "id(i) ---> ",hex(id(i))

i += 1
print "i ---> ",i
print "id(i) ---> ",hex(id(i))

j = 5
print "j ---> ",j
print "id(j) ---> ",hex(id(j))
______________________
i --->  5
id(i) --->  0xa26f880
i --->  6
id(i) --->  0xa26f874
j --->  5
id(j) --->  0xa26f880

#float 
i = 1.5
print "i ---> ",i
print "id(i) ---> ",hex(id(i))

i += 1
print "i ---> ",i
print "id(i) ---> ",hex(id(i))

j = 1.5
print "j ---> ",j
print "id(j) ---> ",hex(id(j))
______________________
i --->  1.5
id(i) --->  0x9e86c8c
i --->  2.5
id(i) --->  0x9e86cac
j --->  1.5
id(j) --->  0x9e86c8c

接下来以Python的list类型为例，可以看到list变量i在append之后，仍然指向同一个内存地址，而j、k的值虽然相同，但是指向的内存地址却不同。我们通过j = k 的赋值语句可以让j、k指向同一个内存地址，对j、k任意一个list变量进行修改，都会影响另外一个list变量的值。比如j变量append(4)时，同时对k变量也产生影响，查看j、k的内存地址，发现它们仍然指向了同个内存地址。

#list
i = [1, 2, 3]
print "i ---> ",i
print "id(i) ---> ",hex(id(i))

i.append(4)
print "i ---> ",i
print "id(i) ---> ",hex(id(i))

j = [1.5, 2.5, 3.5]
print "j ---> ",j
print "id(j) ---> ",hex(id(j))

k = [1.5, 2.5, 3.5]
print "k ---> ",j
print "id(k) ---> ",hex(id(k))

j = k
print "j ---> ",j
print "id(j) ---> ",hex(id(j))
print "k ---> ",j
print "id(k) ---> ",hex(id(k))

j.append(4)
print "j ---> ",j
print "id(j) ---> ",hex(id(j))
print "k ---> ",j
print "id(k) ---> ",hex(id(k))
______________________
i --->  [1, 2, 3]
id(i) --->  0xb73fa1acL
i --->  [1, 2, 3, 4]
id(i) --->  0xb73fa1acL
j --->  [1.5, 2.5, 3.5]
id(j) --->  0xb6fed06cL
k --->  [1.5, 2.5, 3.5]
id(k) --->  0xb6fed04cL
j --->  [1.5, 2.5, 3.5]
id(j) --->  0xb6fed04cL
k --->  [1.5, 2.5, 3.5]
id(k) --->  0xb6fed04cL
j --->  [1.5, 2.5, 3.5, 4]
id(j) --->  0xb6fed04cL
k --->  [1.5, 2.5, 3.5, 4]
id(k) --->  0xb6fed04cL

刚才讲到Python的int类型的两个变量值相同时，Python解释器并不会分别为两个变量申请内存，而是优化的将他们指向同个内存地址。但这里有个例外的情况，当变量s1和s2 存储20个char时，Python仍然将两个变量引用指向了相同内存地址，但当存储为21个char时，Python为s2开辟了新的内存。

s1 =  'a' * 20
s2 =  'a' * 20
print hex(id(s1)), hex(id(s2))
0xb7075320L 0xb7075320L

s1 =  'a' * 21
s2 =  'a' * 21
print hex(id(s1)), hex(id(s2))
0xb70752f0L 0xb7075350L

总结

根据以上的这些例子，我们可以知道Python中的对象分为可变类型和不可变类型，列表、字典是可变类型，而整数、浮点、短字符串、元组等是不可变类型。可变类型的变量赋值与我们了解的C语言机制相同，而不可变类型的变量赋值时，实际上是重新创建一个不可变类型的对象，并将原来的变量重新指向新创建的对象，当然如果没有其他变量引用原有对象时，原有对象就会被回收。这也是Python作为动态类型语言的特点，即变量不需要预先声明类型，当变量在赋值时解释器会根据值的类型创建对应的内存空间进行存储，并将变量指向这个地址空间即可，比如运行a=1时，解释器将变量指向整形值1的地址，当运行a=0.1时，解释器将变量指向浮点值0.1的地址。

说明：此处的例程测试环境为Ubuntu 16.04 LTS 32 位，不同的环境下测试结果可能会由于解释器的优化不同而有所不同。比如有网友发现解释器为两个相同浮点类型值的变量分配了不同的内存空间。