Python 变量作用域、嵌套函数、闭包函数与装饰器

问题说明

在刷leetcode题目的时候,遇到诸多在一个函数中嵌套另一个函数的写法,因此就涉及对不同函数间变量的传递问题的分析,因此本文的目的就是一次性将不同层级函数间的变量作用域、嵌套函数、闭包函数与装饰器之间的关系进行说明。

一、变量作用域

1.1 全局变量与局部变量

局部变量:只能在特定的函数中可以访问的变量
全局变量:定义在所有函数最外面的变量

分辨局部变量与全局变量的规则
假设有一个变量为a,它出现在函数f()里面,可以使用如下规则来判断:

  • 如果有global关键字修饰变量a,则a为全局变量
  • 否则,假如a是参数或者出现在等号左边,则a是局部变量
  • 否则,a与函数f()外层的变量a的属性相同
    a = 1  # 全局变量
    
    def F3():
    	def F():
        	global a  # a是最外层的全局变量  
        	print("In F3's F, a =", a)
    
    	a = 3 # a出现在等号的左边,所以此处的a就是一个F3()函数中的局部变量
    	F()
    	print(a)
    
    F3()
    
    >>>
    In F3's F, a = 1
    3
    # 如果将上述代码中global a这一行注释掉,那么最终的输出将变成如下所示:
    >>>
    In F3's F, a = 3
    3
    
    """
    可以看到,global定义的变量a,是一个全局变量,不管在其他函数中如何将其进行重新赋值,都不会改变其作用范围
    """
    

局部变量可以在外部被赋值,但不可以在外部被调用

所以可以看出,每个变量都有自身的作用域,即其作用范围是有限的,例如上例中a=3的作用域就局限于函数F3()

二、嵌套函数

2.1 嵌套函数

  • 嵌套函数是指在函数内定义的函数
  • 定义在其他函数内部的函数称为内建函数,包含有内建函数的函数称为外部函数
  • 嵌套函数如同局部变量,是局部函数,它只能在外层定义它的函数中使用

嵌套函数类似于嵌套循环,就是函数内又嵌套着函数。先看一种容易理解的情况:

def func2():                  #定义一个函数
    print('我是第二个函数')

def func1():                  #再定义一个函数
    print('我是第一个函数')
    func2()

func1()
>>>
我是第一个函数
我是第二个函数

如果把被调用函数写在函数内部呢,那就是嵌套函数了。如下:

>>>def outer():                 #定义外层函数
      print('我是外层函数')
      def inner():              #定义内层函数
          print('我是内层函数')
    inner()                		#执行内层函数
>>>outer()
我是外层函数
我是内层函数

调用外部函数outer()后,先执行print('我是外层函数'),最后执行inner(),而inner函数内是print('我是内层函数'),所以最后输出了两句话。

2.2 嵌套函数下的局部和全局变量

假设有一个变量a,它出现在函数f里面,可以使用如下规则来判断:

  • 如果有global关键字修饰变量a,那么不管函数f()是不是嵌套函数,a都为全局变量
  • 否则,假如a是参数或者出现在等号左边,则a是局部变量
  • 否则,a应继承上层函数中a的属性
    • 如果函数f不是嵌套函数,那么a为全局变量
    • 如果函数f是嵌套函数,那么a就是上层的a
      相关理解案例:
a = 1  # 全局变量

def F3():
    def F():
        global a  # a是最外层的全局变量
        print("In F3's F, a =", a)

    a = 3
    F()

F3()

>>>
In F3's F, a = 1
a = 1

def F4():
    global a

    def F():
        a = 2  # a是F的局部变量
        print("In F4's F,a=", a)

    F()
    print("In F4, a =", a)  # a是全局变量

F4()

>>>
In F4's F,a= 2
In F4, a = 1
a = 1

def F5():
    def F():  # a不是F的局部变量,那就继承上层函数中a的属性
        print("In F5's F,a =", a)

    a = 3
    F()

F5()

>>>
In F5's F,a = 3

上述嵌套函数的引入,看似好像没啥用,还直接将代码的复杂度提升上去了,搞这么复杂干嘛呢??别着急,往下面看。

三、闭包函数

3.1 闭包函数

以上外层函数和内层函数都没有变量,和参数,那如果传入参数和变量呢?然后把外层函数返回值指向内层函数名:

def outer():               #定义外层函数
    a=1
    print('我是外层函数')
    def inner():           #定义内层函数
        print('我是内层函数')
        print('内层函数打印',a)
    return inner           #返回内层函数名
f=outer()                 #调用外层函数,并把结果赋值给f
>>>我是外层函数

看到结果只执行了外层函数的print,内层函数没有执行。我们看一下f的含义,此时f其实就代表inner,指向inner的内存空间。如果要执行需要f(),我们看一下结果:

def outer():               #定义外层函数
    a=1
    print('我是外层函数')
    def inner():           #定义内层函数
        print('我是内层函数')
        print('内层函数打印',a)
    return inner                 #执行内层函数
f=outer()                 #调用外层函数,并把结果赋值给f
f()
>>>我是外层函数
我是内层函数
内层函数打印 1

看到内层函数和外层函数都执行了,并且外层函数中的变量a被打印出来。这就是闭包函数,外层函数的变量可以被内层函数调用,这样外层函数变量和内层函数一起构成了类似‘’肚子里的一块区域‘’,这块区域被保护起来,变量只供内层函数‘’享用‘’。类似于封装的效果。内层函数不会立马被执行,当再次调用f时,内层函数才会执行。

调用f()方法打印的a值是1,也就是说在inner()中使用的是外部方法outer()中定义的变量a。但是在调用f()时,outer()函数已经返回了,本地的作用域也不存在了,那么是如何访问到a的值呢?实际上此处就涉及到了变量的作用域相关问题。

闭包函数需要有三个条件,缺一不可:

1.必须有一个内嵌函数

2.内部函数引用外部函数变量

3.外部函数必须返回内嵌函数

3.2 闭包函数作用域

再把上面的代码变形

def outer():               #定义外层函数
    a=1
    print('我是外层函数')
    def inner():            #定义内层函数
        a=10
        print('我是内层函数')
        print('内层函数打印',a)
    return inner                 #执行内层函数
f=outer()                 #调用外层函数,并把结果赋值给f
f()
>>>我是外层函数
我是内层函数
内层函数打印 10

在内层函数中又有a=10,此时并不是改变的外层函数中的a,而是在内层函数中定义的新变量,是两个不同的东西。从结果也能看出来。这就是作用域的问题。

内层函数中调用的变量首先会从内层函数中找,找不到就去外层函数中找,再找不到就到函数外代码中找,再找不到就到内置的模块中找,最后还是找不到,就报错。

在内层函数中修改外层函数中的变量
在内层函数中修改外部函数中的变量a,此时会报错

def outer():               #定义外层函数
    a=1
    print('我是外层函数')
    def inner():            #定义内层函数
        a+=10
        print('我是内层函数')
        print('内层函数打印',a)
    return inner                 #执行内层函数
f=outer()                 #调用外层函数,并把结果赋值给f
f()
>>>我是外层函数
Traceback (most recent call last):
  File "C:\Users\13061\PycharmProjects\huaweidata\迭代器.py", line 14, in <module>
    f()
  File "C:\Users\13061\PycharmProjects\huaweidata\迭代器.py", line 9, in inner
    a+=10
UnboundLocalError: local variable 'a' referenced before assignment

也就是说,我们在inner()中使用a+=10时,相当于a = a + 10,此时对a进行赋值时,python会默认a是局部变量,但是inner内并没有定义a,所以会报错。
但是如果是将a改为list()类型,可以不可以呢?

def outer():
    num = [10]
    def inner():
        num[0] += 1
        return num[0]
    return inner

test = outer()
test()
>>>
11

通过运行,我们发现可以得到想要的结果,因为list是可变类型,此时num指向的是自由变量num,并对num中的数据进行了改变。
但是这样每次都把不可变数据转换成可变数据进行传递太麻烦了,所以python3引入了nonlocal声明,作用是把变量标记为自由变量,即使在函数中为变量赋予了新值,也会变成自由变量。

如果想修改外部函数中的变量,必须加一个nonlocal的声明,修改如下。这和在函数中修改全局变量,加global 有异曲同工之妙

def outer():               #定义外层函数
    a=1
    print('我是外层函数')
    def inner():            #定义内层函数
        nonlocal a 
        a+=10
        print('我是内层函数')
        print('内层函数打印',a)
    return inner                 #执行内层函数
f=outer()                 #调用外层函数,并把结果赋值给f
f()

python2没有nonlocal,所以需要把变量存储为可变变量的元素或属性,并把对象绑定给自由变量。

闭包函数的意义:
1、上面讲了一点就是把某些变量和函数代码保护到‘’肚子里‘’,这样可以起到保护的作用。

2、可以构造一个新函数,上面例子中外层函数和内层函数都没有传变量,那么如果传入变量呢。

请看:

def outer(a):               #定义函数要一杯不同类型的饮料   
   def inner(b):            #定义内层函数,饮料的容量
        print(f'要一杯{a}')
        print(f'容量是{b}毫升')
    return inner                 #执行内层函数
blacktea=outer('红茶')                 #调用外层函数,并把结果赋值给f
greentea=outer('绿茶')
blacktea(300)
greentea(500)
>>>要一杯红茶
容量是300毫升
要一杯绿茶
容量是500毫升

四、装饰器

4.1 装饰器基础

对方法进行装饰,在方法运行前后添加其他功能

import time
def outer(func):
    def inner():
        time1 = time.time()
        func()
        time2 = time.time()
        return time2 - time1
    return inner

@outer
def test():
    print("test")

相当于:test = outer(test),此装饰器就是用来计算方法运行时间的

4.2 装饰器的执行顺序

装饰器在被装饰的函数定义之后立即运行,通常是在导入时(即python加载模块时)

def outer(func):
    print("%s outer running" % func)
    def inner():
        print("%s inner running" % func)
        return func
    return inner

@outer
def test1():
    print("test1 runing")

@outer
def test2():
    print("test2 runing")

def test3():
    print("test3 runing")

def main():
    print("main runing")
    test1()
    test2()
    test3()

if __name__ == "__main__":
    main()    

结果为:

<function test1 at 0x104b4bd90> outer running
<function test2 at 0x104b4bea0> outer running
main runing
<function test1 at 0x104b4bd90> inner running
<function test2 at 0x104b4bea0> inner running
test3 runing

可以看出,在函数test1test2定义后,装饰器outer立即被执行。

4.3 参数化装饰器

参数化装饰器即为带参数的装饰器,如果装饰器需要额外的参数,就可以创建一个装饰器工厂函数,把参数传给它,如下例:

register = set()
def dec(active=True):
    def outer(func):
        print("running %s (active=%s)" % (func, active))
        if active:
            register.add(func)
        else:
            register.discard(func)
        return func
    return outer

@dec(active=False)
def test1():
    return "runing test1"

@dec()
def test2():
    print("runing test2")

def test3():
    print("running test3")

def main():
    print("main runing")
    test1()
    test2()
    test3()
    print(register)

if __name__ == "__main__":
    main() 

运行结果如下:

running <function test1 at 0x106c71e18> (active=False)
running <function test2 at 0x106c71ea0> (active=True)
main runing
runing test2
running test3
{<function test2 at 0x106c71ea0>}

可以看出,active作为了额外参数传到装饰器outer中对register内的参数进行了控制

  • 17
    点赞
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值