python基础（5）：深刻理解 python 中的赋值、引用、拷贝、做用域

目录[-]

• 一、先来看个问题吧：

• 二、引用 VS 拷贝：

• 三、加强赋值以及共享引用：

• 四、python 从 2k 到 3k，语句变函数引起的变量做用域问题  

在 python 中赋值语句老是创建对象的引用值，而不是复制对象。所以，python 变量更像是指针，而不是数据存储区域，

这点和大多数 OO 语言相似吧，好比 C++、java 等 ~

一、先来看个问题吧：

在Python中，令values=[0,1,2];values[1]=values,为什么结果是[0,[...],2]?

1	>>> values = [0, 1, 2]

2	>>> values[1] = values

3	>>> values

4	[0, [...], 2]

我预想应当是  

[0, [0, 1, 2], 2]

但结果却为什么要赋值无限次？

能够说 Python 没有赋值，只有引用。你这样至关于建立了一个引用自身的结构，因此致使了无限循环。为了理解这个问题，有个基本概念须要搞清楚。

Python 没有「变量」，咱们平时所说的变量其实只是「标签」，是引用。

执行 

values = [0, 1, 2]

的时候，Python 作的事情是首先建立一个列表对象 [0, 1, 2]，而后给它贴上名为 values 的标签。若是随后又执行 

values = [3, 4, 5]

的话，Python 作的事情是建立另外一个列表对象 [3, 4, 5]，而后把刚才那张名为 values 的标签从前面的 [0, 1, 2] 对象上撕下来，从新贴到 [3, 4, 5] 这个对象上。 

至始至终，并无一个叫作 values 的列表对象容器存在，Python 也没有把任何对象的值复制进 values 去。过程如图所示： 

执行

values[1] = values

的时候，Python 作的事情则是把 values 这个标签所引用的列表对象的第二个元素指向 values 所引用的列表对象自己。执行完毕后，values 标签仍是指向原来那个对象，只不过那个对象的结构发生了变化，从以前的列表 [0, 1, 2] 变成了 [0, ?, 2]，而这个 ? 则是指向那个对象自己的一个引用。如图所示： 
 
要达到你所须要的效果，即获得 [0, [0, 1, 2], 2] 这个对象，你不能直接将 values[1] 指向 values 引用的对象自己，而是须要吧 [0, 1, 2] 这个对象「复制」一遍，获得一个新对象，再将 values[1] 指向这个复制后的对象。Python 里面复制对象的操做因对象类型而异，复制列表 values 的操做是

values[:] #生成对象的拷贝或者是复制序列，再也不是引用和共享变量，但此法只能顶层复制

因此你须要执行 

values[1] = values[:]

Python 作的事情是，先 dereference 获得 values 所指向的对象 [0, 1, 2]，而后执行 [0, 1, 2][:] 复制操做获得一个新的对象，内容也是 [0, 1, 2]，而后将 values 所指向的列表对象的第二个元素指向这个复制二来的列表对象，最终 values 指向的对象是 [0, [0, 1, 2], 2]。过程如图所示： 

往更深处说，values[:] 复制操做是所谓的「浅复制」(shallow copy)，当列表对象有嵌套的时候也会产生出乎意料的错误，好比

1	a = [0, [1, 2], 3]

2

b = a[:]

3

a[0] = 8

4	a[1][1] = 9

问：此时 a 和 b 分别是多少？ 

正确答案是 a 为 [8, [1, 9], 3]，b 为 [0, [1, 9], 3]。发现没？b 的第二个元素也被改变了。想一想是为何？不明白的话看下图 

正确的复制嵌套元素的方法是进行「深复制」(deep copy)，方法是

1	import copy

2

3	a = [0, [1, 2], 3]

4	b = copy.deepcopy(a)

5

a[0] = 8

6	a[1][1] = 9

二、引用 VS 拷贝：

（1）没有限制条件的分片表达式（L[:]）可以复制序列，但此法只能浅层复制。

（2）字典 copy 方法，D.copy() 可以复制字典，但此法只能浅层复制

（3）有些内置函数，例如 list，可以生成拷贝 list(L)

（4）copy 标准库模块可以生成完整拷贝：deepcopy 本质上是递归 copy

（5）对于不可变对象和可变对象来讲，浅复制都是复制的引用，只是由于复制不变对象和复制不变对象的引用是等效的（由于对象不可变，当改变时会新建对象从新赋值）。因此看起来浅复制只复制不可变对象（整数，实数，字符串等），对于可变对象，浅复制实际上是建立了一个对于该对象的引用，也就是说只是给同一个对象贴上了另外一个标签而已。

01	L = [1, 2, 3]

02	D = {'a':1, 'b':2}

03

A = L[:]

04	B = D.copy()

05	print "L, D"

06	print  L, D

07	print "A, B"

08	print A, B

09	print "--------------------"

10	A[1] = 'NI'

11	B['c'] = 'spam'

12	print "L, D"

13	print  L, D

14	print "A, B"

15	print A, B

16

17

18

L, D

19	[1, 2, 3] {'a': 1, 'b': 2}

20

A, B

21	[1, 2, 3] {'a': 1, 'b': 2}

22	--------------------

23

L, D

24	[1, 2, 3] {'a': 1, 'b': 2}

25

A, B

26	[1, 'NI', 3] {'a': 1, 'c': 'spam', 'b': 2}

三、增强赋值以及共享引用：

x = x + y，x 出现两次，必须执行两次，性能很差，合并必须新建对象 x，而后复制两个列表合并

属于复制/拷贝

x += y，x 只出现一次，也只会计算一次，性能好，不生成新对象，只在内存块末尾增长元素。

当 x、y 为list时， += 会自动调用 extend 方法进行合并运算，in-place change。

属于共享引用

01	L = [1, 2]

02

M = L

03	L = L + [3, 4]

04	print L, M

05	print "-------------------"

06	L = [1, 2]

07

M = L

08	L += [3, 4]

09	print L, M

10

11

12	[1, 2, 3, 4] [1, 2]

13	-------------------

14	[1, 2, 3, 4] [1, 2, 3, 4]

四、python 从 2k 到 3k，语句变函数引起的变量做用域问题  

先看段代码：

1	def test():

2

a = False

3	exec ("a = True")

4	print ("a = ", a)

5

test()

6

7

b = False

8	exec ("b = True")

9	print ("b = ", b)

在 python 2k 和 3k 下 你会发现他们的结果不同：

1

2K：

2

a =  True

3

b =  True

4

5

3K：

6	a =  False

7

b =  True

这是为何呢？

由于 3k 中 exec 由语句变成函数了，而在函数中变量默认都是局部的，也就是说

你所见到的两个 a，是两个不一样的变量，分别处于不一样的命名空间中，而不会冲突。

具体参考 《learning python》P331-P332

知道缘由了，咱们能够这么改改：

01	def test():

02

a = False

03	ldict = locals()

04	exec("a=True",globals(),ldict)

05	a = ldict['a']

06

print(a)

07

08

test()

09

10

b = False

11	exec("b = True", globals())

12	print("b = ", b)

这个问题在  stackoverflow 上已经有人问了，并且 python 官方也有人报了 bug。。。

具体连接在下面：

http://stackoverflow.com/questions/7668724/variables-declared-in-execed-code-dont-become-local-in-python-3-documentatio

http://bugs.python.org/issue4831

http://stackoverflow.com/questions/1463306/how-does-exec-work-with-locals

这是一个典型的 python 2k 移植到 3k 不兼容的案例，相似的还有不少，也算是移植的坑吧~

具体的 2k 与 3k 有哪些差别能够看这里：

使用 2to3 将代码移植到 Python 3

http://woodpecker.org.cn/diveintopython3/porting-code-to-python-3-with-2to3.html

REF：

《learning python》：P130、P13四、P20二、P204 、P245

http://www.zhihu.com/question/21000872/answer/16856382