参数的做用域

一、做用域 :函数外的变量的做用域为全局做用域(命名空间对应全局命名空间),函数体内的变量(未用global声明)的做用域为内部做用域(对应局部命名空间);函数体内的变量称为局部变量闭包

>>> x = 1  ###x的做用域为全局做用域,对应全局命名空间函数

>>> def foo():
  x = 42 ###x的做用域为局部做用域 ,对应局部命名空间,具体的做用域只在函数体内;局部命名空间中的x指向42
  return xspa

>>> x
1
>>> foo() ###调用foo函数的时候,局部命名空间就被建立,仅做用于函数内代码块
42
>>> x ###调用的全局做用域(全局命名空间)中的x指向的值,因此x=1
1code

二、Shadowing屏蔽的问题;若是函数体内的局部变量和全局变量的名字相同,在函数体内引用全局变量的话,局部变量会把全局变量屏蔽掉blog

 

>>> def combine(parameter):
    external = 'berry'
    print(parameter+external)ip

>>> external = 'Sunshine'
>>> #想生成'parameter+'Sunshine''作用域

>>> combine('you are my ')
you are my berry  ###这个结果并非咱们期待的结果,由于局部变量和全局变量的名字同样,因此局部变量把全局变量屏蔽了io

三、globals()函数,无参数,将获取全局变量的字典类型,使用方法 globals()['全局变量名'] 返回全局变量对应的值;修改上面的函数function

 

>>> def combine(parameter):
    external = 'berry'
    print(parameter+globals()['external'])class

>>> external = 'Sunshine'
>>> combine('you are my ')
you are my Sunshine

 

四、函数内从新绑定全局变量(指向新的内容),若是函数有必要改变全局变量,使用global 变量名;用global声明 函数体内的变量为全局变量

 

>>> x = 1
>>> def change_global():
  global x
  x = x+1

>>> change_global()
>>> x   
2

五、嵌套做用域,一个函数内嵌套了另外一个函数,外层函数返回内层函数(内层函数未被调用只是返回);内层函数是能够访问外层函数的变量的,这个就叫嵌套做用域;

例子:

 

>>> def multiplier(factor):
    def multiplyByFactor(number):
      return(number*factor)####外层函数multiplier的变量factor,被内层函数multiplyByFactor引用了
    return multiplyByFactor###外层函数返回内层函数

 

 

 相似multiplyByFactor函数,存储于一个封闭的做用域的行为叫作闭包(由于它引用的变量都在函数体内或者外层函数内,若是factor为全局变量,则它就不是闭包)

查看一个函数是不是闭包用:函数.__closure__

 

>>> def multiplier(factor):
    def multiplyByFactor(number):
      return(number*factor)
    print(multiplyByFactor.__closure__)###双下划线
    return multiplyByFactor

 

>>> multiplier(2)
(<cell at 0x000001A961B4AEB8: int object at 0x00007FFE82BBE370>,) ##显示cell说明函数multiplyByFactor是闭包
<function multiplier.<locals>.multiplyByFactor at 0x000001A961B79F28>###这个返回值只说明multiplier内嵌了函数multiplyByFactor,并不表示multiplyByFactor是闭包

 

非闭包嵌套函数

 

>>> def multiplier(factor):
    def multiplyByFactor(number):
      return(number*number2)###未引用外层函数的变量
    print(multiplyByFactor.__closure__)
    return multiplyByFactor

 

>>> number2 =3
>>> multiplier(2)
None  ###说明multiplyByFactor函数不是一个闭包函数,由于它引用的变量是本身的变量和全局变量,未引用外层函数变量
<function multiplier.<locals>.multiplyByFactor at 0x000001A961B92048>

 

>>> def multiplier(factor):
    def multiplyByFactor(number):
      return(number*factor*number2)###引用自身变量、外层函数变量、全局变量也不是闭包
    print(multiplier.__closure__)
    return multiplyByFactor

>>> number2 =3
>>> multiplier(2)
None
<function multiplier.<locals>.multiplyByFactor at 0x000001A961B79F28>

nonlocal函数可使内部函数从新对外层函数变量进行重绑定

>>> def counter():
    counter = 0
    def do_nonlocal():
      nonlocal counter
      counter+=1
      return counter
    return do_nonlocal

>>> ct = counter()

>>> print(ct())

1
>>> print(ct())

2
>>> print(ct())

3
>>> ct = counter()  ###counter=0被重定向为1

>>> print(ct())

1

 注意:若是内层函数变量名与外部函数变量名重复,外部函数变量名会覆盖内层函数变量名

提示:Inspection info: This inspection detects shadowing names defined in outer scopes.

def scope_test():
    def func_local():
        ##Inspection info: This inspection detects shadowing names defined in outer scopes.
        parameter = 'local parameter'  

    def statement_nonlocal():
        nonlocal parameter
        parameter = 'nonlocal parameter'

    def statement_global():
        global parameter
        parameter = 'global parameter'
    parameter = 'out scope parameter'
    func_local()
    print('After local assignment:',parameter)
    statement_nonlocal()
    print('After nonlocal assignmet:',parameter)
    statement_global()
    print("After global assignment:",parameter)

if __name__ == '__main__':
    scope_test()
    print('now the parameter is:',parameter)

相关文章
相关标签/搜索