深入理解Python中变量赋值的问题
前言
在Python中变量名规则与其他大多数高级语言一样，都是受C语言影响的，另外变量名是大小写敏感的。
Python是动态类型语言，也就是说不需要预先声明变量类型，变量的类型和值在赋值那一刻被初始化，下面详细介绍了Python的变量赋值问题，一起来学习学习吧。
我们先看一下如下代码:
c={}
deffoo():
f=dict(zip(list("abcd"),[1,2,3,4]))
c.update(f)
if__name__=="__main__":
a=b=d=c
b['e']=5
d['f']=6
foo()
print(a)
print(b)
print(c)
print(d)
输出结果：
{'a':1,'c':3,'b':2,'e':5,'d':4,'f':6}
{'a':1,'c':3,'b':2,'e':5,'d':4,'f':6}
{'a':1,'c':3,'b':2,'e':5,'d':4,'f':6}
{'a':1,'c':3,'b':2,'e':5,'d':4,'f':6}
如果你对以上输出结果不感到奇怪，那么就不必往下看了。实际上本文要讨论的内容非常简单，不要为此浪费您宝贵的时间。
Python属于动态语言，程序的结构可以在运行的过程中随时改变，而且python还是弱类型的语言，所以如果你是从静态、强类型编程语言转过来的，理解起Python的赋值，刚开始可能会感觉有些代码有点莫名其妙。
可能你会以为上面代码的输出会是这样的：
{}
{'e':5}
{}
{'f':6}
你可能认为a没有被改变，因为没有看到哪里对它做了改变；b和d的改变是和明显的；c呢，因为是在函数内被改变的，你可能认为c会是一个局部变量，所以全局的c不会被改变。
实际上，这里的a,b,c,d同时指向了一块内存空间，这可内存空间保存的是一个字典对象。这有点像c语言的指针，a,b,c,d四个指针指向同一个内存地址，也就是给这块内存其了4个笔名。所以，不管你改变谁，其他三个变量都会跟着变化。那为什么c在函数内部被改变，而且没有用global申明，但全局的c去被改变了呢？
我们再来看一个例子：
>>>a={1:1,2:2}
>>>b=a
>>>a[3]=3
>>>b
{1:1,2:2,3:3}
>>>a=4
>>>b
{1:1,2:2,3:3}
>>>a
4
当b=a时，a与b指向同一个对象，所以在a中添加一个元素时，b也发生变化。而当a=4时，a就已经不再指向字典对象了，而是指向一个新的int对象（python中整数也是对象），这时只有b指向字典，所以a改变时b没有跟着变化。这是只是说明了什么时候赋值变量会发生质的改变，而以上的问题还没有被解决。
那么，我么再来看一个例子：
classTestObj(object):
pass
x=TestObj()
x.x=8
d={"a":1,"b":2,"g":x}
xx=d.get("g",None)
xx.x=10
print("x.x:%s"%x.x)
print("xx.x:%s"%xx.x)
print("d['g'].x:%s"%d['g'].x)
#Out:
#x.x:10
#xx.x:10
#d['g'].x:10
由以上的实例可以了解到，如果仅改变对象的属性（或者说成是改变结构），所有指向该对象的变量都会随之改变。但是如果一个变量重新指向了一个对象，那么其他指向该对象的变量不会随之变化。所以，最开始的例子中，c虽然在函数内部被改变，但是c是全局的变量，我们只是在c所指向的内存中添加了一个值，而没有将c指向另外的变量。
需要注意的是，有人可能会认为上例中的最后一个输出应该是d['g'].x:8。这样理解的原因可能是觉得已经把字典中‘g'所对应的值取出来了，并重新命名为xx，那么xx就与字典无关了。其实际并不是这样的，字典中的key所对应的value就像是一个指针指向了一片内存区域，访问字典中key时就是去该区域取值，如果将值取出来赋值给另外一个变量，例如xx=d['g']或者xx=d.get("g",None)，这样只是让xx这个变量也指向了该区域，也就是说字典中的键‘g'和xx对象指向了同一片内存空间，当我们只改变xx的属性时，字典也会发生变化。
下例更加直观的展示了这一点：
classTestObj(object):
pass
x=TestObj()
x.x=8
d={"a":1,"b":2,"g":x}
print(d['g'].x)
xx=d["g"]
xx.x=10
print(d['g'].x)
xx=20
print(d['g'].x)
#Out:
#8
#10
#10
这个知识点非常简单，但如果没有理解，可能无法看明白别人的代码。这一点有时候会给程序设计带来很大的便利，例如设计一个在整个程序中保存状态的上下文：
classContext(object): pass deffoo(context): context.a=10 context.b=20 x=1 defhoo(context): context.c=30 context.d=40 x=1 if__name__=="__main__": context=Context() x=None foo(context) hoo(context) print(x) print(context.a) print(context.b) print(context.c) print(context.d) #Out： #None #10 #20 #30 #40
示例中我们可以把需要保存的状态添加到context中，这样在整个程序的运行过程中这些状态能够被任何位置被使用。
在来一个终结的例子，执行外部代码：
outer_code.py
from__future__importprint_function
definitialize(context):
g.a=333
g.b=666
context.x=888
defhandle_data(context,data):
g.c=g.a+g.b+context.x+context.y
a=np.array([1,2,3,4,5,6])
print("outerspace:ais%s"%a)
print("outerspace:contextis%s"%context)
main_exec.py
from__future__importprint_function
importsys
importimp
frompprintimportpprint
classContext(object):
pass
classPersistentState(object):
pass
#Scriptstartsfromhere
if__name__=="__main__":
outer_code_moudle=imp.new_module('outer_code')
outer_code_moudle.__file__='outer_code.py'
sys.modules["outer_code"]=outer_code_moudle
outer_code_scope=code_scope=outer_code_moudle.__dict__
head_code="importnumpyasnp\nfrommain_execimportPersistentState\ng=PersistentState()"
exec(head_code,code_scope)
origin_global_names=set(code_scope.keys())
withopen("outer_code.py","rb")asf:
outer_code=f.read()
import__future__
code_obj=compile(outer_code,"outer_code.py","exec",flags=__future__.unicode_literals.compiler_flag)
exec(code_obj,code_scope)
#去除掉内建名字空间的属性，仅保留外部代码中添加的属性
outer_code_global_names=set(outer_code_scope.keys())-origin_global_names
outer_func_initialize=code_scope.get("initialize",None)
outer_func_handle_data=code_scope.get("handle_data",None)
context=Context()
context.y=999
outer_func_initialize(context)
outer_func_handle_data(context,None)
g=outer_code_scope["g"]
assertg.c==2886
print("g.c:%s"%g.c)
print(dir(g))
print(dir(context))
pprint(outer_code_moudle.__dict__)
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流。