Python函数中作用域教程

本地全局

>>> a = 1
 
>>> def add(y,z):
 
... 　　 print(y+z+a)
... 　　 return y+z+a
...
>>> add(1,2)
4
4
>>>

因为这个a是在这个文件内最外层注册的变量名，所以他是全局变量
全局变量能够在函数内部直接使用，而不需要特定的声明
全局变量的生命周期：在整个程序运行期间。

本地变量名：y,z

y和z的注册地址在函数内部，y和z是局部变量
局部变量生命周期：函数运行期间
局部的同名变量优先级高于全局的，如果局部没有这个变量，会尝试从上一级作用域空间查找同名变量

>>> a = 1
>>> def change():
...     a = 2
...     print(a)
...
>>> a
1
>>> change() #打印函数内部修改之后的a
2
>>> a #打印外部a
1

外部的a并没有被修改

这是因为，函数内部赋值的变量除非声明为全局变量或非本地变量，否则均为本地变量
这里的a = 2，因为是在函数内部使用赋值的，所以解释器会把它当作一个函数内部的变量，他的作用域是这个函数内部
如果想修改一个全局变量，只需要在函数内部被修改变量前加global语句

函数传参需要注意的地方

函数传参：

可变对象作为参数传递，可以在函数内部直接修改初始数据对象的值。
不可变对象传递时，无法直接修改初始全局数据对象的值，是在局部添加新得同名变量赋值，不会影响全局同名变量对象，要想修改全局变量对象只需要在函数内部被修改变量前加global语句

传递一个不可变对象，按值传递：

>>> a = 1
>>> def change():
...     a = 2
...     print(a)
...
>>> change()
2
>>> a
1

可以看到不可变数据传递时：加上blobal就可以修改全局变量对象。

>>> a = 1
>>> def change():
...     global a
...     a = 2
...     print(a)
...
>>> a
1
>>> change()
2
>>> a
2

传递一个可变对象（列表，字典，集合），按引用传递：

>>> a = [1,2,3]
>>> def change():
...     a[0] = 'a'
...     print(a)
...
>>> a
[1, 2, 3]
>>> change()
['a', 2, 3]
>>> a
['a', 2, 3]
#可变对象作为参数传递，传的是引用，内部修改影响全局

从下面代码中就可以看出局部的同名变量优先级高于全局的，如果局部没有这个变量，会尝试从上一级作用域空间查找同名变量，如果有则不会修改全局同名变量

>>> a = [1]
>>> def change():
...     a = [1,2,3]
...     a[0] = 'a'
...     print('内',a)
...
>>> a
[1]
>>> change()
内 ['a', 2, 3]
>>> a
[1]
>>>

可变数据在函数内部和全局下，直接修改，其实是一个，不可变数据在函数内部和全局下，同名是不一样的，

>>> changed = [1,2,3]
>>> unchanged = '123'
>>> def func():
...     changed[0] = 'a'
...     print('内：',changed)
...
>>> def func1():
...     unchanged = 'zhangan'
...     print('内：',unchanged)
...
>>> func()
内： ['a', 2, 3]
>>> func1()
内： zhangan
>>> changed
['a', 2, 3]
>>> unchanged
'123'
>>>`

不管是可变不可变，只要是等号赋值，不是修改，都是创建了一个新的同名局部变量　（一般在编写代码的时候局部变量最好不要更全局变量同名）

>>> changed = [1,2,3]
>>> unchanged = '123'
>>> def func():
...     changed = ['a','b','c']
...     print('内：',changed)
...
>>> def func1():
...     unchanged = 'zhangan'
...     print('内：',unchanged)
...
>>> func()
内： ['a', 'b', 'c']
>>> func1()
内： zhangan
>>> changed
[1, 2, 3]
>>> unchanged
'123'
>>>

a = [1,2,3,[5,6]]
b = 'abc'

def func(c,d):
    c[3][0] = 'a'
    a = 'abccasdaskjldhaskjldsakdah' #创建了个新的
    global b
    b = 'adsadadsadsadasdasdqweqhkjashckjas' #直接赋值 就是创建的新的
    print('内：',c)
    print('内：',d)
    print('内：',a)
    print('内：',b)
func(a,b)
print('外：',a)
print('外：',b)

输出结果为：

内： [1, 2, 3, ['a', 6]]
内： abc
内： abccasdaskjldhaskjldsakdah
内： adsadadsadsadasdasdqweqhkjashckjas
外： [1, 2, 3, ['a', 6]]
外： adsadadsadsadasdasdqweqhkjashckjas

Python函数中作用域教程

猜你喜欢