靜態作用域python輸出

A. 在python中使用內置函數什麼和什麼可以查看並輸出局部變數和全局變數列表

要在 Python 中查看和列印局部變數和全局變數的列表，可以使用 和 內置函數。這些函數返回一個字典，分別包含當前作用域中所有局部變數和全局變數的名稱和值。然後，您可以使用字典的方法循環訪問鍵值對並將其列印到輸出中。locals()globals()items()

下面是如何使用 and 函數在 Python 中列印局部變數和全局變數的示例：locals()globals()

如您所見，該函數返回一個包含局部變數的字典，而該函數返回一個包含全局變數 、 和 的字典。您可以使用此方法在 Python 中查看和列印任何范圍內的局部變數和全局變數列表。locals()local_varglobals()__name__global_varprint_vars

回答不易望請採納

B. 深入探究Python中變數的拷貝和作用域問題

這篇文章主要介紹了Python中變數的拷貝和作用域問題,包括一些賦值、引用問題,以及相關函數在Python2和3版本之間的不同,需要的朋友可以參考下
在
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]
我預想應當是
?
1
[0,
[0,
1,
2],
2]
但結果卻為何要賦值無限次?
可以說
Python
沒有賦值，只有引用。你這樣相當於創建了一個引用自身的結構，所以導致了無限循環。為了理解這個問題，有個基本概念需要搞清楚。
Python
沒有「變數」，我們平時所說的變數其實只是「標簽」，是引用。
執行
?
1
values
=
[0,
1,
2]
的時候，Python
做的事情是首先創建一個列表對象
[0,
1,
2]，然後給它貼上名為
values
的標簽。如果隨後又執行
?
1
values
=
[3,
4,
5]
的話，Python
做的事情是創建另一個列表對象
[3,
4,
5]，然後把剛才那張名為
values
的標簽從前面的
[0,
1,
2]
對象上撕下來，重新貼到
[3,
4,
5]
這個對象上。
至始至終，並沒有一個叫做
values
的列表對象容器存在，Python
也沒有把任何對象的值復制進
values
去。過程如圖所示：
執行
?
1
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[:]
#生成對象的拷貝或者是復制序列，不再是引用和共享變數，但此法只能頂層復制
所以你需要執行
?
1
values[1]
=
values[:]
Python
做的事情是，先
dereference
得到
values
所指向的對象
[0,
1,
2]，然後執行
[0,
1,
2][:]
復制操作得到一個新的對象，內容也是
[0,
1,
2]，然後將
values
所指向的列表對象的第二個元素指向這個復制二來的列表對象，最終
values
指向的對象是
[0,
[0,
1,
2],
2]。過程如圖所示：
往更深處說，values[:]
復制操作是所謂的「淺復制」(shallow
)，當列表對象有嵌套的時候也會產生出乎意料的錯誤，比如
?
1
2
3
4
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
)，方法是
?
1
2
3
4
5
6
import


a
=
[0,
[1,
2],
3]
b
=
.deep(a)
a[0]
=
8
a[1][1]
=
9
2、引用
VS
拷貝：
(1)沒有限制條件的分片表達式(L[:])能夠復制序列，但此法只能淺層復制。
(2)字典

方法，D.()
能夠復制字典，但此法只能淺層復制
(3)有些內置函數，例如
list，能夠生成拷貝
list(L)
(4)
標准庫模塊能夠生成完整拷貝：deep
本質上是遞歸

(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.()
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
從2.x
到3.x，語句變函數引發的變數作用域問題
先看段代碼：
?
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)
在
python
2.x
和
3.x
下
你會發現他們的結果不一樣：
?
1
2
3
4
5
6
7
2.x：
a
=
True
b
=
True

3.x：
a
=
False
b
=
True
這是為什麼呢?
因為
3.x
中
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)
這個問題在
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

C. Python其實很簡單 第十二章 函數與變數的作用域

在前面已經多次提到函數這個概念，之所以沒有解釋什麼是函數，是因為程序中的函數和數學中的函數差不多，如input()、range()等都是函數，這些都是Python的標准函數，直接使用就可以了。根據需要，用戶也可以自定義函數。

12.1 函數

函數的結構：

def 函數名(參數)：

函數體

return 返回值

例如：數學中的函數f(x)=2x+5在Python中可以定義如下：

def f(x):

y=2*x+5

return(y)

如果x取值為3，可以使用如下語句調用函數：

f(3)

下面給出完整的程序代碼：

def f(x):

y=2*x+5

return(y)

res=f(3)

print(res)

運行結果：11

如上例中的x是函數f(x)的參數，有時也被稱為形式參數（簡稱形參），在函數被調用時，x被具體的值3替換y就是函數的返回值，這個值3也被稱為實際參數（簡稱實參）。

上例中的y是函數f(x)的返回值。並不是所有的函數都有參數和返回值。如下面的函數：

def func():

print('此為無參數傳遞、無返回值的函數')

func()

輸出結果：此為無參數傳遞、無返回值的函數

可以看出，該函數func()無參數，故調用時不用賦給參數值。

函數也可以有多個參數，如f(x,y)=x²+y²，可用Python語言定義如下：

def f(x,y):

z=x**2+y**2

return z

print(f(2,3)) #調用函數f(x,y)

輸出結果：13

也可以通過直接給參數列表中的參數賦值的方法，為參數添加默認值，如果用戶賦予參數值，則按照用戶賦值執行，否則使用默認值。例如：

def f(x,y=3):

z=x**2+y**2

return z

若調用時參數列表為（2,1），即x賦值為2，y賦值為1：

print(f(2,1))

輸出結果為：5

若調用時參數列表為（2），即x賦值為2，y賦值省缺，則y使用默認值：

print(f(2))

輸出結果為：13

回調函數，又稱函數回調，是將函數作為另一函數的參數。

例如：

def func(fun,m,n):

fun(m,n)

def f_add(m,n):

print('m+n=',m+n)

def f_mult(m,n):

print('m*n=',m*n)

func(f_add,2,3)

func(f_mult,2,3)

輸出結果：

m+n= 5

m*n= 6

在f_add(m,n)和f_mult(m,n)被定義前，func(fun,m,n)中的fun(m,n)就已經調用了這兩個函數，即「先調用後定義」，這也是回調函數的特點。

如果無法預知參數的個數，可以在參數前面加上*號，這種參數實際上對應元組類型。譬如，參會的人數事先不能確定，只能根據與會人員名單輸入：

def func(*names):

print('今天與會人員有：')

for name in names:

print(name)

func('張小兵','陳曉梅','李大海','王長江')

運行後，輸出結果為：

今天與會人員有：

張小兵

陳曉梅

李大海

王長江

參數為字典類型，需要在參數前面加上**號。

def func(**kwargs):

for i in kwargs:

print(i,kwargs[i])

func(a='a1',b='b1',c='c1')

輸出結果為：

a a1

b b1

c c1

一個有趣的實例：

def func(x,y,z,*args,**kwargs):

print(x,y,z)

print(args)

print(kwargs)

func('a','b','c','Python','is easy',py='python',j='java',ph='php')

輸出結果：

a b c # 前三個實參賦給前三個形參

('Python', 'is easy') # *args接收元組數據

{'py': 'python', 'j': 'java', 'ph': 'php'} # **kwargs接收字典數據

12.2 變數的作用域

變數的作用域即變數的有效范圍，可分為全局變數和局部變數。

局部變數

在函數中定義的變數就是局部變數，局部變數的作用域僅限於函數內部使用。

全局變數

在主程序中定義的變數就是全局變數，但在函數中用關鍵字global修飾的變數也可以當做全局變數來使用。

全局變數的作用域是整個程序，也就是說，全局變數可以在整個程序中可以訪問。

下面通過實例去討論：

程序1：

a=1 # a為全局變數

def a_add():

print('a的初值：',a) # 在函數中讀取a的值

a_add() # 調用函數a_add()

a+=1 # 主程序語句，a增加1

print('a現在的值是：',a) # 主程序語句，讀取a的值

運行結果：

a的初值： 1

a現在的值是： 2

這個結果和我們想像的一樣，全局變數a既可以在主程序中讀取，也可以在子程序（函數）中讀取。

程序2：

a=1

def a_add():

a+=1

print('a的初值：',a)

a_add()

print('a現在的值是：',a)

運行程序1時出現如下錯誤提示：

UnboundLocalError: local variable 'a' referenced before assignment

意思是：局部變數'a'在賦值之前被引用。

從語法上來講，該程序沒有錯誤。首先定義了一個全局變數a並賦值為1，又定義了一個函數a_add()，函數內的語句a+=1就是出錯的根源，雖然我們的初衷是想讓全局變數a的值增加1，但從錯誤提示看，這個語句中的a並不是全局變數，而是局部變數。看來，在函數中讀取全局變數的值是沒有問題的（在程序1中已經得到了驗證），但要在函數中改變全局變數的值是不行的（在程序2的錯誤提示a+=1中的a 是局部變數，而非全局變數）。

怎樣解決這個問題？

程序3：

a=1

def a_add(x):

x+=1

return x

print('a的初值：',a)

a=a_add(a)

print('a現在的值是：',a)

運行結果：

a的初值： 1

a現在的值是： 2

結果的確是正確的，但在函數a_add(x)中沒有調用變數a（沒有出現變數a）。

程序4：

a=1

def a_add(a):

a+=1

return a

print('a的初值：',a)

a=a_add(a)

print('a現在的值是：',a)

運行結果：

a的初值： 1

a現在的值是： 2

對比程序4和程序3不難發現，其實程序4隻是簡單的把函數的參數x變成了a，這個a的實質和程序3中的x還是一樣的。這進一步證實，函數中的a是局部變數，與主程序的全局變數a有著本質的區別。

程序5：

a=1

def a_add():

global a

a+=1

print('a的初值：',a)

a_add()

print('a現在的值是：',a)

運行結果：

a的初值： 1

a現在的值是： 2

程序5和程序2相比較，僅僅是在函數中添加了一個定義「global a」，此時的局部變數a就可以當做全局變數使用，由於它和全局變數a同名，自然也就不用區分a究竟是全局變數還是局部變數了，在主程序和該函數內都可以訪問、修改變數a的值了。

雖然使用global可使變數使用起來非常方便，但也容易引起混淆，故在使用過程中還是謹慎為好。

12.3 函數的遞歸與嵌套

遞歸，就是函數調用它自身。遞歸必須設置停止條件，否則函數將無法終止，形成死循環。

以計算階乘為例：

def func(n):

if n==1:

return 1

else:

return n*func(n-1) #func( )調用func( )

print(func(5))

運行結果為：120

嵌套，指在函數中調用另外的函數。這是程序中常見的一種結構，在此不再贅述。

匿名函數

Python中可以在參數前加上關鍵字lambda定義一個匿名函數，這樣的函數一般都屬於「一次性」的。

例如：

程序1：這是一個常規的函數定義和調用。

def f_add(x,y):

return x+y

print(f_add(2,3))

輸出結果：5

程序2：使用lambda定義匿名函數。

f_add=lambda x,y:x+y

print(f_add(2,3))

輸出結果：5

從上面的代碼可以看出，使用lambda僅僅減少了一行代碼。f_add=lambda x,y:x+y中的f_add不是變數名，而是函數名。程序1和程序2的print( )語句中的參數都是一樣的——調用函數f_add( )。所以，匿名函數並沒有太多的優點。

D. Python中靜態方法和類方法的區別

面相對象程序設計中，類方法和靜態方法是經常用到的兩個術語。
邏輯上講：類方法是只能由類名調用；靜態方法可以由類名或對象名進行調用。
在C++中，靜態方法與類方法邏輯上是等價的，只有一個概念，不會混淆。
而在python中，方法分為三類實例方法、類方法、靜態方法。代碼如下：
class Test(object):
def InstanceFun(self):
print("InstanceFun");
print(self);
@classmethod
def ClassFun(cls):
print("ClassFun");
print(cls);
@staticmethod
def StaticFun():
print("StaticFun");
t = Test();
t.InstanceFun();＃ 輸出InstanceFun，列印對象內存地址「」
Test.ClassFun(); # 輸出ClassFun，列印類位置
Test.StaticFun(); # 輸出StaticFun
t.StaticFun(); # 輸出StaticFun
t.ClassFun(); # 輸出ClassFun，列印類位置
Test.InstanceFun(); # 錯誤，TypeError: unbound method instanceFun() must be called with Test instance as first argument

Test.InstanceFun(t); # 輸出InstanceFun，列印對象內存地址「」
t.ClassFun(Test); # 錯誤 classFun() takes exactly 1 argument (2 given)
可以看到，在PYTHON中，兩種方法的主要區別在於參數。實例方法隱含的參數為類實例self，而類方法隱含的參數為類本身cls。
靜態方法無隱含參數，主要為了類實例也可以直接調用靜態方法。

所以邏輯上類方法應當只被類調用，實例方法實例調用，靜態方法兩者都能調用。主要區別在於參數傳遞上的區別，實例方法悄悄傳遞的是self引用作為參數，而類方法悄悄傳遞的是cls引用作為參數。
Python實現了一定的靈活性使得類方法和靜態方法，都能夠被實例和類二者調用

E. #抬抬小手學Python# Python 之作用域下的 global 和 nonlocal 關鍵字

該部分內容涉及 Python 變數作用域相關知識，變數作用域指的是變數的有效作用范圍，直接理解就是 Python 中的變數不是任意位置都可以訪問的，有限制條件。

一般情況下變數的作用域變化范圍是 塊級、函數、類、模塊、包等，級別是從小到達。Python 中是沒有塊級作用域的，所以我們在寫代碼的時候，下面的代碼是正確的。

在 Python 中常見的塊級作用域有 if 語句、for 語句、while 語句、with 上下文語句。

上文已經提及了作用域是 Python 程序可以直接訪問一個變數的作用范圍，Python 的作用域一共有 4 種，分別如下：

一個比較經典的案例如下：

在 Python 中變數尋找的順序是從內到外，先局部，然後外部，在全局，在內建，這種規則叫做 LEGB 規則 。

增加以下學習的趣味性，你可以研究下述代碼中變數是如何變化的。

定義在 函數內部 的變數擁有一個局部作用域，定義在 函數外部 的變數擁有全局作用域。

輸出結果，函數內部是 123 ，函數外部依舊是 0 。

如果希望函數內部（內部作用域）可以修改外部作用域的變數，需要使用 global 關鍵字。

此時輸出的就都是 123 了，還有一點需要注意，在函數內容如果希望修改全局變數的值， global 關鍵字一定要寫在變數操作前。

該代碼會出現語法錯誤：

全局變數還存在一個面試真題，經常出現，請問下述代碼運行結果。

如果要修改嵌套作用域（Enclosing 作用域）中的變數，需要 nonlocal 關鍵字，測試代碼如下：

輸出結果自行測試，注意 nonlocal 關鍵字必須是 Python3.X+版本，Python 2.X 版本會出現語法錯誤：

在多重嵌套中， nonlocal 只會上溯一層，如果上一層沒有，則會繼續上溯，下述代碼你可以分別注釋查看結果。

局部變數和全局變數具體有哪些，可以通過 locals() 和 globals() 兩個內置函數獲取。

本篇博客為大家說明了 Python 的作用域，並且對 global 和 nonlocal 關鍵字進行了學習，希望對你有所幫助。

F. python裡面變數作用域是什麼

變數作用域：python可以直接查找名稱到對象的映射(命名空間)的部分。

python有built–in、global、enclosing、local這四種作用域

built–in：內建作用域，包含了內建的變數和關鍵字。

global：全局作用域，定義在所有函數外，當前模塊(.py源文件)的全局變數。

enclosing：閉包函數外的函數(非局部也非全局)，比如有一個函數a，a里有另一個函數b，對於b里的變數來說，a中的作用域就是enclosing。

local：局部作用域，腳本最內層，比如函數里。

G. Python語言中作用域怎麼理解

命名空間 是從命名到對象的映射。當前命名空間主要是通過 Python 字典實現的，不過通常不關心具體的實現方式（除非出於性能考慮），以後也有可能會改變其實現方式。以下有一些命名空間的例子：內置命名（像 abs() 這樣的函數，以及內置異常名）集，模塊中的全局命名，函數調用中的局部命名。某種意義上講對象的屬性集也是一個命名空間。關於命名空間需要了解的一件很重要的事就是不同命名空間中的命名沒有任何聯系，例如兩個不同的模塊可能都會定義一個名為 maximize 的函數而不會發生混淆－用戶必須以模塊名為前綴來引用它們。
順便提一句，我稱 Python 中任何一個「.」之後的命名為 屬性 －－例如，表達式 z.real 中的 real 是對象 z 的一個屬性。嚴格來講，從模塊中引用命名是引用屬性：表達式 modname.funcname 中，modname 是一個模塊對象，funcname 是它的一個屬性。因此，模塊的屬性和模塊中的全局命名有直接的映射關系：它們共享同一命名空間！[1]
屬性可以是只讀過或寫的。後一種情況下，可以對屬性賦值。你可以這樣做： modname.the_answer = 42 。可寫的屬性也可以用 del 語句刪除。例如： del modname.the_answer 會從 modname 對象中刪除 the_answer 屬性。
不同的命名空間在不同的時刻創建，有不同的生存期。包含內置命名的命名空間在 Python 解釋器啟動時創建，會一直保留，不被刪除。模塊的全局命名空間在模塊定義被讀入時創建，通常，模塊命名空間也會一直保存到解釋器退出。由解釋器在最高層調用執行的語句，不管它是從腳本文件中讀入還是來自互動式輸入，都是 __main__ 模塊的一部分，所以它們也擁有自己的命名空間（內置命名也同樣被包含在一個模塊中，它被稱作 builtins ）。
當調用函數時，就會為它創建一個局部命名空間，並且在函數返回或拋出一個並沒有在函數內部處理的異常時被刪除。（實際上，用遺忘來形容到底發生了什麼更為貼切。）當然，每個遞歸調用都有自己的局部命名空間。
作用域 就是一個 Python 程序可以直接訪問命名空間的正文區域。這里的直接訪問意思是一個對名稱的錯誤引用會嘗試在命名空間內查找。盡管作用域是靜態定義，在使用時他們都是動態的。每次執行時，至少有三個命名空間可以直接訪問的作用域嵌套在一起：