本文转自:http://my.oschina.net/leejun2005/blog/145911
在 python 中赋值语句总是建立对象的引用值,而不是复制对象。因此,python 变量更像是指针,而不是数据存储区域,
这点和大多数 OO 语言类似吧,比如 C++、java 等 ~
1、先来看个问题吧:
在Python中,令values=[0,1,2];values[1]=values,为何结果是[0,[...],2]?
1
2
3
4
|
>>> values
=
[
0
,
1
,
2
]
>>> values[
1
]
=
values
>>> values
[
0
, [...],
2
]
|
[0, [0, 1, 2], 2]
可以说 Python 没有赋值,只有引用。你这样相当于创建了一个引用自身的结构,所以导致了无限循环。为了理解这个问题,有个基本概念需要搞清楚。
Python 没有「变量」,我们平时所说的变量其实只是「标签」,是引用。
执行
values = [0, 1, 2]
values = [3, 4, 5]
至始至终,并没有一个叫做 values 的列表对象容器存在,Python 也没有把任何对象的值复制进 values 去。过程如图所示:
执行
values[1] = values
要 达到你所需要的效果,即得到 [0, [0, 1, 2], 2] 这个对象,你不能直接将 values[1] 指向 values 引用的对象本身,而是需要吧 [0, 1, 2] 这个对象「复制」一遍,得到一个新对象,再将 values[1] 指向这个复制后的对象。Python 里面复制对象的操作因对象类型而异,复制列表 values 的操作是
values[:] #生成对象的拷贝或者是复制序列,不再是引用和共享变量,但此法只能顶层复制
values[1] = values[:]
往更深处说,values[:] 复制操作是所谓的「浅复制」(shallow copy),当列表对象有嵌套的时候也会产生出乎意料的错误,比如
1
2
3
4
|
a
=
[
0
, [
1
,
2
],
3
]
b
=
a[:]
a[
0
]
=
8
a[
1
][
1
]
=
9
|
正确答案是 a 为 [8, [1, 9], 3],b 为 [0, [1, 9], 3]。发现没?b 的第二个元素也被改变了。想想是为什么?不明白的话看下图
正确的复制嵌套元素的方法是进行「深复制」(deep copy),方法是
1
2
3
4
5
6
|
import
copy
a
=
[
0
, [
1
,
2
],
3
]
b
=
copy.deepcopy(a)
a[
0
]
=
8
a[
1
][
1
]
=
9
|
2、引用 VS 拷贝:
(1)没有限制条件的分片表达式(L[:])能够复制序列,但此法只能浅层复制。
(2)字典 copy 方法,D.copy() 能够复制字典,但此法只能浅层复制
(3)有些内置函数,例如 list,能够生成拷贝 list(L)
(4)copy 标准库模块能够生成完整拷贝:deepcopy 本质上是递归 copy
(5)对于不可变对象和可变对象来说,浅复制都是复制的引用,只是因为复制不变对象和复制不变对象的引用是等效的(因为对象不可变,当改变时会新建对象重新赋值)。所以看起来浅复制只复制不可变对象(整数,实数,字符串等),对于可变对象,浅复制其实是创建了一个对于该对象的引用,也就是说只是给同一个对象贴上了另一个标签而已。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
L
=
[
1
,
2
,
3
]
D
=
{
'a'
:
1
,
'b'
:
2
}
A
=
L[:]
B
=
D.copy()
print
"L, D"
print
L, D
print
"A, B"
print
A, B
print
"--------------------"
A[
1
]
=
'NI'
B[
'c'
]
=
'spam'
print
"L, D"
print
L, D
print
"A, B"
print
A, B
L, D
[
1
,
2
,
3
] {
'a'
:
1
,
'b'
:
2
}
A, B
[
1
,
2
,
3
] {
'a'
:
1
,
'b'
:
2
}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
L, D
[
1
,
2
,
3
] {
'a'
:
1
,
'b'
:
2
}
A, B
[
1
,
'NI'
,
3
] {
'a'
:
1
,
'c'
:
'spam'
,
'b'
:
2
}
|
3、增强赋值以及共享引用:
x = x + y,x 出现两次,必须执行两次,性能不好,合并必须新建对象 x,然后复制两个列表合并
属于复制/拷贝
x += y,x 只出现一次,也只会计算一次,性能好,不生成新对象,只在内存块末尾增加元素。
当 x、y 为list时, += 会自动调用 extend 方法进行合并运算,in-place change。
属于共享引用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
L
=
[
1
,
2
]
M
=
L
L
=
L
+
[
3
,
4
]
print
L, M
print
"-------------------"
L
=
[
1
,
2
]
M
=
L
L
+
=
[
3
,
4
]
print
L, M
[
1
,
2
,
3
,
4
] [
1
,
2
]
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
[
1
,
2
,
3
,
4
] [
1
,
2
,
3
,
4
]
|
4、python 从 2k 到 3k,语句变函数引发的变量作用域问题
先看段代码:
1
2
3
4
5
6
7
8
9
|
def
test():
a
=
False
exec
(
"a = True"
)
print
(
"a = "
, a)
test()
b
=
False
exec
(
"b = True"
)
print
(
"b = "
, b)
|
1
2
3
4
5
6
7
|
2K
:
a
=
True
b
=
True
3K
:
a
=
False
b
=
True
|
因为 3k 中 exec 由语句变成函数了,而在函数中变量默认都是局部的,也就是说
你所见到的两个 a,是两个不同的变量,分别处于不同的命名空间中,而不会冲突。
具体参考 《learning python》P331-P332
知道原因了,我们可以这么改改:
1
2
3
4
5
6
7
8
9
10
11
12
|
def
test():
a
=
False
ldict
=
locals
()
exec
(
"a=True"
,
globals
(),ldict)
a
=
ldict[
'a'
]
print
(a)
test()
b
=
False
exec
(
"b = True"
,
globals
())
print
(
"b = "
, b)
|
具体链接在下面:
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、P134、P202、P204 、P245
http://www.zhihu.com/question/21000872/answer/16856382
理解 Python 的 LEGB