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页面的作用范围内的。