深入理解Python中變量賦值的問題
前言
在Python中變量名規(guī)則與其他大多數高級語言一樣，都是受C語言影響的，另外變量名是大小寫敏感的。
Python是動態(tài)類型語言，也就是說不需要預先聲明變量類型，變量的類型和值在賦值那一刻被初始化，下面詳細介紹了Python的變量賦值問題，一起來學習學習吧。
我們先看一下如下代碼:
c = {}
def foo():
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 屬于動態(tài)語言，程序的結構可以在運行的過程中隨時改變，而且 python 還是弱類型的語言，所以如果你是從靜態(tài)、強類型編程語言轉過來的，理解起 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 也發(fā)生變化。而當 a = 4 時， a 就已經不再指向字典對象了，而是指向一個新的 int 對象（python 中整數也是對象），這時只有 b 指向字典，所以 a 改變時 b 沒有跟著變化。這是只是說明了什么時候賦值變量會發(fā)生質的改變，而以上的問題還沒有被解決。
那么，我么再來看一個例子：
class TestObj(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 就像是一個指針指向了一片內存區(qū)域，訪問字典中 key 時就是去該區(qū)域取值，如果將值取出來賦值給另外一個變量，例如 xx = d['g'] 或者 xx = d.get("g", None)，這樣只是讓 xx 這個變量也指向了該區(qū)域，也就是說字典中的鍵 ‘g' 和 xx 對象指向了同一片內存空間，當我們只改變 xx 的屬性時，字典也會發(fā)生變化。
下例更加直觀的展示了這一點：
class TestObj(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
這個知識點非常簡單，但如果沒有理解，可能無法看明白別人的代碼。這一點有時候會給程序設計帶來很大的便利，例如設計一個在整個程序中保存狀態(tài)的上下文：
class Context(object): pass def foo(context): context.a = 10 context.b = 20 x = 1 def hoo(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
示例中我們可以把需要保存的狀態(tài)添加到 context 中，這樣在整個程序的運行過程中這些狀態(tài)能夠被任何位置被使用。
在來一個終結的例子，執(zhí)行外部代碼：
outer_code.py
from __future__ import print_function
def initialize(context):
g.a = 333
g.b = 666
context.x = 888
def handle_data(context, data):
g.c = g.a + g.b + context.x + context.y
a = np.array([1, 2, 3, 4, 5, 6])
print("outer space: a is %s" % a)
print("outer space: context is %s" % context)
main_exec.py
from __future__ import print_function
import sys
import imp
from pprint import pprint
class Context(object):
pass
class PersistentState(object):
pass
# Script starts from here
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 = "import numpy as np\nfrom main_exec import PersistentState\ng=PersistentState()"
exec(head_code, code_scope)
origin_global_names = set(code_scope.keys())
with open("outer_code.py", "rb") as f:
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"]
assert g.c == 2886
print("g.c: %s" % g.c)
print(dir(g))
print(dir(context))
pprint(outer_code_moudle.__dict__)
總結
以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作能帶來一定的幫助，如果有疑問大家可以留言交流。
相關文章
本文主要介紹了python實現(xiàn)字母閃爍效果的示例代碼，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2022-08-08
今天小編就為大家分享一篇python實現(xiàn)回旋矩陣方式(旋轉矩陣)，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2019-12-12
今天小編就為大家分享一篇python文件絕對路徑寫法介紹（windows)，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2019-12-12
這篇文章主要介紹了Python中JSON數據的相互轉化詳解,JSON 是一種輕量級的數據交互格式,可以按照 JSON 指定的格式去組織和封裝數據,2023-12-12
JSON 本質是一個帶有特定格式的字符串,需要的朋友可以參考下
解決.ui文件生成的.py文件運行不出現(xiàn)界面的方法
今天小編就為大家分享一篇解決.ui文件生成的.py文件運行不出現(xiàn)界面的方法，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2019-06-06
這篇文章主要介紹了python獲取柵格點和面值的實現(xiàn)，具有很好的參考價值，希望對大家有多幫助。一起跟隨小編過來看看吧2020-03-03
這篇文章主要介紹了Pycharm github配置實現(xiàn)過程圖解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-10-10
Sklearn（全稱 SciKit-Learn），是基于 Python 語言的機器學習工具包。本文將簡單的介紹SKlearn安裝與使用，想要入坑機器學習的同學可以參考下2021-05-05
python+pywinauto+lackey實現(xiàn)PC端exe自動化的示例代碼
這篇文章主要介紹了python+pywinauto+lackey實現(xiàn)PC端exe自動化的示例代碼，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2021-04-04
由于工作需要,將爬蟲的文件要保存為csv,以前只是保存為json,下面這篇文章主要給大家介紹了關于如何使用python?scrapy爬取天氣并導出csv文件的相關資料,需要的朋友可以參考下2022-08-08