深入探究Python中变量的拷贝和作用域问题

在 python 中赋值语句总是建立对象的引用值,而不是复制对象。因此,python 变量更像是指针,而不是数据存储区域,

这点和大多数 OO 语言类似吧,比如 C++、java 等 ~
1、先来看个问题吧:

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

>>> values = [0, 1, 2]
>>> values[1] = values
>>> values
[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),当列表对象有嵌套的时候也会产生出乎意料的错误,比如

a = [0, [1, 2], 3]
b = a[:]
a[0] = 8
a[1][1] = 9

问:此时 a 和 b 分别是多少?

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

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

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)对于不可变对象和可变对象来说,浅复制都是复制的引用,只是因为复制不变对象和复制不变对象的引用是等效的(因为对象不可变,当改变时会新建对象重新赋值)。所以看起来浅复制只复制不可变对象(整数,实数,字符串等),对于可变对象,浅复制其实是创建了一个对于该对象的引用,也就是说只是给同一个对象贴上了另一个标签而已。

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。

属于共享引用

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 从2.x 到3.x,语句变函数引发的变量作用域问题 

先看段代码:

def test():
  a = False
  exec ("a = True")
  print ("a = ", a)
test()

b = False
exec ("b = True")
print ("b = ", b)

在 python 2.x 和 3.x 下 你会发现他们的结果不一样:

2.x:
a = True
b = True

3.x:
a = False
b = True

这是为什么呢?

因为 3.x 中 exec 由语句变成函数了,而在函数中变量默认都是局部的,也就是说

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

具体参考 《learning python》P331-P332

知道原因了,我们可以这么改改:

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)

这个问题在  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

(0)

相关推荐

  • 解析Python中的变量、引用、拷贝和作用域的问题

    在Python中,变量是没有类型的,这和以往看到的大部分编辑语言都不一样.在使用变量的时候,不需要提前声明,只需要给这个变量赋值即可.但是,当用变量的时候,必须要给这个变量赋值:如果只写一个变量,而没有赋值,那么Python认为这个变量没有定义.如下: >>> a Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'a'

  • 讲解Python中for循环下的索引变量的作用域

    我们从一个测试开始.下面这个函数的功能是什么? def foo(lst): a = 0 for i in lst: a += i b = 1 for t in lst: b *= i return a, b 如果你觉得它的功能是"计算lst中所有元素的和与积",不要沮丧.通常很难发现这里的错误.如果在大堆真实的代码中发现了这个错误就非常厉害了.--当你不知道这是一个测试时,很难发现这个错误. 这里的错误是在第二个循环体中使用了i而不是t.等下,这到底是怎么工作的?i在第一个循环外应该是

  • 从局部变量和全局变量开始全面解析Python中变量的作用域

    理解全局变量和局部变量 1.定义的函数内部的变量名如果是第一次出现, 且在=符号前,那么就可以认为是被定义为局部变量.在这种情况下,不论全局变量中是否用到该变量名,函数中使用的都是局部变量.例如: num = 100 def func(): num = 123 print num func() 输出结果是123.说明函数中定义的变量名num是一个局部变量,覆盖全局变量.再例如: num = 100 def func(): num += 100 print num func() 输出结果是:Unb

  • Python中的变量和作用域详解

    作用域介绍 python中的作用域分4种情况: L:local,局部作用域,即函数中定义的变量: E:enclosing,嵌套的父级函数的局部作用域,即包含此函数的上级函数的局部作用域,但不是全局的: G:globa,全局变量,就是模块级别定义的变量: B:built-in,系统固定模块里面的变量,比如int, bytearray等. 搜索变量的优先级顺序依次是:作用域局部>外层作用域>当前模块中的全局>python内置作用域,也就是LEGB. x = int(2.9) # int bu

  • 深入探究Python中变量的拷贝和作用域问题

    在 python 中赋值语句总是建立对象的引用值,而不是复制对象.因此,python 变量更像是指针,而不是数据存储区域, 这点和大多数 OO 语言类似吧,比如 C++.java 等 ~ 1.先来看个问题吧: 在Python中,令values=[0,1,2];values[1]=values,为何结果是[0,[...],2]? >>> values = [0, 1, 2] >>> values[1] = values >>> values [0, [.

  • 对python中list的拷贝与numpy的array的拷贝详解

    1.python中列表list的拷贝,会有什么需要注意的呢? python变量名相当于标签名. list2=list1 ,直接赋值,实质上指向的是同一个内存值.任意一个变量list1(或list2)发生改变,都会影响另一个list2(或list1). eg: >>> list1=[1,2,3,4,5,6] >>> list2=list1 >>> list1[2]=88 >>> list1 [1, 2, 88, 4, 5, 6] >

  • 深入理解Python中变量赋值的问题

    前言 在Python中变量名规则与其他大多数高级语言一样,都是受C语言影响的,另外变量名是大小写敏感的. Python是动态类型语言,也就是说不需要预先声明变量类型,变量的类型和值在赋值那一刻被初始化,下面详细介绍了Python的变量赋值问题,一起来学习学习吧. 我们先看一下如下代码: c = {} def foo(): f = dict(zip(list("abcd"), [1, 2 ,3 ,4])) c.update(f) if __name__ == "__main__

  • Python中变量的输入输出实例代码详解

    1.变量的输入: input函数: input() input("请输入银行卡密码") password = input("请输入银行卡密码") 变量名 = input("XXX") # 用输入函数给变量赋值 输入函数给变量赋值举例: 注:所有input()得到的数据类型都是str字符串类型 2.变量类型的转换函数: • int(x) # str转整数 • float(x) # str转小数 转换举例: 3.输入综合练习: # 1.输入苹果的单价

  • 关于探究python中sys.argv时遇到的问题详解

    自动化任务 这是一篇关于我在自己学习python自动化办公中遇到的问题的笔记. 关于文章读写 我用到的书是<python编程快速上手>,在学习第八章时遇到了理解上的困难.问题主要是在接触sys.argv和在创建bat文件时,出现了理解上的障碍. sys.argv这个函数是我们写python脚本中最常用的一个函数. sys是Python的一个「标准库」,也就是官方出的「模块」,是「System」的简写,封装了一些系统的信息和接口. 官方的文档参考:https://docs.python.org/

  • Python中变量的作用域详解

    目录 1.作用于的概念 2.局部变量 3.全局变量 4.变量的查找 5.作用域中可变数据类型变量 6.多函数程序执行流程 总结 1.作用于的概念 变量作用域指的是变量生效的范围,在Python中一共有两种作用域. 全局作用域 全局作用域在程序执行时创建,在程序执行结束时销毁.所有函数以外的区域都是全局作用域.在全局作用域中定义的变量,都属于全局变量,全局变量可以在程序的任意位置被访问. 函数作用域 函数作用域在函数调用时创建,在调用结束时销毁.函数每调用一次就会产生一个新的函数作用域(不调用不产

  • 详细探究Python中的字典容器

    dictionary 我们都曾经使用过语言词典来查找不认识的单词的定义.语言词典针对给定的单词(比如 python)提供一组标准的信息.这种系统将定义和其他信息与实际的单词关联(映射)起来.使用单词作为键定位器来寻找感兴趣的信息.这种概念延伸到 Python 编程语言中,就成了特殊的容器类型,称为 dictionary. dictionary 数据类型在许多语言中都存在.它有时候称为关联 数组(因为数据与一个键值相关联),或者作为散列表.但是在 Python 中,dictionary 是一个很好

  • 进一步探究Python中的正则表达式

    字符串是编程时涉及到的最多的一种数据结构,对字符串进行操作的需求几乎无处不在.比如判断一个字符串是否是合法的Email地址,虽然可以编程提取@前后的子串,再分别判断是否是单词和域名,但这样做不但麻烦,而且代码难以复用. 正则表达式是一种用来匹配字符串的强有力的武器.它的设计思想是用一种描述性的语言来给字符串定义一个规则,凡是符合规则的字符串,我们就认为它"匹配"了,否则,该字符串就是不合法的. 所以我们判断一个字符串是否是合法的Email的方法是: 创建一个匹配Email的正则表达式:

  • python中的对象拷贝示例 python引用传递

    何谓引用传递,我们来看一个C++交换两个数的函数: 复制代码 代码如下: void swap(int &a, int &b){    int temp;    temp = a;    a = b;    b = temp;} 这个例子就是一个引用传递的例子!目的是说明一下概念:引用传递的意思就是说你传递的是对象的引用,对这个引用的修改也会导致原有对象的改变.学过C/C++的朋友们都知道,在交换2个数的时候,如果自己实现一个swap函数,需要传递其引用或者指针. Python直接使用引用传

随机推荐