python變數作用域for

A. python 變數初值突變問題或者叫變數作用域問題

不是不相干，是你把x和i的值修改了
比如這句：
x=2
squared = [x ** 2 for x in range(4)]
你在第一句的時候x是2
但是第二句展開的話就變成了
x = 0

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

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

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

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

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

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

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

C. Python程序 for的目標<target>變數

這種問題自己實踐一下就能解決也來問？
作用域只存在於函數，模塊之間，函數嵌套也算。
內部->函數外部->全局->內建

D. python中函數變數作用域和類變數作用域怎麼搞都錯，煩躁中

python中，變數的作用域要弄清楚。只有mole、class、def、lambda才會引入作用域，其他的代碼塊是不會引入作用域的。
1
圖一中，你在函數中聲明了d為全局變數，但這樣是無效的，程序運行結果，已經說明這一點。

global這個關鍵字，是用來「在函數中修改全局變數值」的聲明，而不是「在局部函數中定義一個全局變數」的聲明。這里要注意一下。
你可以再局部函數外面聲明變數d，再加上你原先的函數，就可以修改、訪問這個變數了。

2
在類中函數的變數，作用域只在函數中。圖二中，jian這個變數分別在yu（），yu1（）兩個函數中，是處於不同的定義域中的，是不能相互訪問的。
所以，在各自函數中，只有先定義了jian變數，才能再使用。
如果想在yu1（）中訪問yu（）中的jian變數，就需要將jian變數變成全局變數，即在class中定義一個全局變數jian，這樣yu1(),yu()函數都可以訪問了

E. python中函數中定義的變數只能在該函數題中起作用對嗎

函數中定義的變數只能在函數體重起作用，Python在函數中定義的變數只能在該函數體中才可以起作用，只要出了這個函數，那麼其他的地方就無法訪問這個變數，因為該變數的作用域只在這個函數中，所以只在本函數體內有效。

因為定義了局部變數只能在其被聲明的函數內部訪問，要想在程序的全域進行訪問只能通過定義全局變數的方法進行實現，這些只要在程序控制范圍內都可以調用。

一般情況下變數就分為這兩大類，一類是全局變數，一類是局部變數。

Python常用的控制語句：

1、if語句，當條件成立時運行語句塊。經常與else，elif（相當於else if）配合使用、for語句，遍歷列表、字元串、字典、集合等迭代器，依次處理迭代器中的每個元素。

2、while語句，當條件為真時，循環運行語句塊、try語句，與except，finally配合使用處理在程序運行中出現的異常情況、class語句，用於定義類型。

3、def語句，用於定義函數和類型的方法、pass語句，表示此行為空，不運行任何操作。

4、from…import語句，從包導入模塊或從模塊導入某個對象、import … as語句，將導入的對象賦值給一個變數、in語句，判斷一個對象是否在一個字元串、列表、元組里。

Python代碼編寫注意：

開發者有意讓違反了縮進規則的程序不能通過編譯，所以在進行Python代碼的書寫時一定要注意代碼的縮進。

以上內容參考：網路-Python

F. python中,我想在for循環外用循環內的變數的值,怎麼操作

我嚓來，哥哥是不是，你在外邊定義不就好了。裡面也可以訪問，就是說擴大一下作用域就好了。

G. python 2.7 變數作用域的疑問

在函數中定義和修改全局變數，需要使用global關鍵字。但訪問全局變數（不修改它的值），可以省略global關鍵字。python這樣設計的意義在於，防止python程序員不小心修改了全局變數。使用global關鍵字後，程序員很清楚自己正在做什麼。

在例三中，b()函數並沒有修改全局變數u。u是一個對象的引用，有唯一的對象ID。在修改了變數的引用，導致變數ID改變是，才算是「修改了對象」。例如：

u={}
deffoo():
globalu
u=1
returnu
printfoo()

這是全局變數u被修改，因為它由一個字典變成了一個int對象，它的值發生了變化。

望採納，謝謝支持！

H. 深入探究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

I. python變數的作用域到底怎麼理解怎麼用呢謝謝！

你可以 在 B頁面 裡面直接 調用 一下 函數
運行一下 ，你可以發現應該和 剛才 執行A 頁面 報的是同樣的錯誤；

這是 因為 在B 頁面裡面 並沒有 s1List 這樣一個數組

在運行A頁面時，因為有了 from b import * ，python解釋器就可以找的getS1和getS2這樣的函數名；可以 在 import 之後 print dir() 來查看 當前作用域下可用的名字 ，可以看到 getS1 和getS2 都在其中

之所以 執行 A頁面錯誤，是A頁面調用 函數 getS1 時，在B頁面中 執行 函數時找不到 s1List這個數組，因為在A 頁面的那個 s1List 是不在 B頁面的作用范圍內的。