闭包&变量的作用域

一、闭包【重点掌握】

​ 函数只是一段可执行代码，编译后就“固化”了，每个函数在内存中只有一份实例，得到函数的入口点便可以执行函数了。函数还可以嵌套定义，即在一个函数内部可以定义另一个函数，有了嵌套函数这种结构，便会产生闭包问题

# 1.需求：在一个函数中访问另一个函数中的变量
# a.方式一：设置返回值，通过调用函数访问
# def func1():
#     num1 = 10
#     return num1
# def func2():
#     num2 = 20
#     r = func1()
#     print(r)
# func2()

# b.方式二：进行函数的嵌套定义，可以直接访问
# 外部函数
# def func1():
#     print("111被调用了")
#     num1 = 10
#     # 内部函数
#     def func2():
#         print("222被调用了~~")
#         num2 = 20
#         print(num1,num2)
# func1()

print("*" * 30)

# 2.嵌套定义的函数如何调用
#a.方式一：在外部函数中直接调用内部函数
def func1():
    print("111被调用了")
    num1 = 10
    def func2():
        print("222被调用了~~")
        num2 = 20
        print(num1,num2)
    func2()
func1()

print("*" * 30)

# b.方式二：将内部函数的引用【函数名】设置为外部函数的返回值
def func1():
    print("111被调用了")
    num1 = 10
    def func2():
        print("222被调用了~~")
        num2 = 20
        print(num1,num2)
    return func2

# 分步调用
f1 = func1()   # f1--->func2
# print(f1)
f1()   # 函数的本质：如果一个变量指向一个函数，则该变量可以当做函数调用

# 直接调用
func1()()

# print(func1())   # 调用，获取函数的返回值
# print(func1)    # 函数本身


# 3.闭包
"""
两个函数嵌套定义，如果内部函数访问了外部函数中的变量，则会形成一个闭包，此时，将外部函数中的变量称为临时变量
"""
# a.
def func1():
    num1 = 10
    def func2():
        num2 = 20
        print(num1,num2)
    return func2
func1()()

# b.
def func1(a):
    num1 = 10
    def func2():
        num2 = 20
        print(num1,num2,a)
    return func2
func1(3)()

# c.
def func1(a):
    num1 = 10
    def func2(b):
        num2 = 20
        print(num1,num2,a,b)
    return func2
func1(3)(23)

# d
def func1(a):
    num1 = 10
    def func2(b):
        num2 = 20
        print(num1,num2,a,b)
        return  num1 + num2 + a + b
    return func2
f = func1(3)    # f--->func2
r = f(4)
print(r)

# 注意：书写一个闭包，除了遵守内部函数访问外部函数中的变量的规则之外，
# 其他的用法，如：设置参数，设置返回值和普通函数的用法完全相同

二、变量的作用域【重点掌握】

1.作用域的分类

变量的作用域指的是变量可以使用的范围

程序的变量并不是在任意位置都可以访问，访问权限取决于这个变量是在哪里赋值的

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。

【面试题】Python的作用域一共有4种，分别是

​ L:Local,局部作用域，特指内部函数

​ E:Enclosing,函数作用域【内部函数外的函数中】

​ G:Global,全局作用域

​ B:Built-in,内建作用域【内置作用域】 num = int(“244”)

查找方式：以L—>E—>G—>B,在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找

注意：Python中只有模块（module）、类（class）以及函数（def、lambda）才会引入新的作用域，其他的代码块，例如if/elif/else、try/except、for/while等是不会引入新的作用域的，也就是说这些语句内定义的变量，在外部也可以使用

# 1.分类
num1 = 10    # G:Global,全局作用域,在当前文件中的任意位置都可以被访问
def outter1():
    num2 = 20   # E:Enclosing,函数作用域【内部函数外的函数中】,只能在外部函数中被访问
    def inner1():
        num3 = 30  # L:Local,局部作用域，特指内部函数,只能在内部函数中被访问
        print("inner:",num1,num2,num3)
    print("outter:",num1,num2)
    return inner1
f1 = outter1()
f1()
print("global:",num1)

# 总结：将变量定义在不同的位置，变量将拥有不同的作用域，将拥有不同的访问权限

# 2.不同作用域下中的变量不重名，在可以被访问的前提下，可以直接访问

# 3.不同作用域下中的变量重名，访问的原则是就近原则
num = 10
def outter1():
    num = 20
    def inner1():
        num = 30
        print("inner:",num)
    print("outter:",num)
    return inner1
f1 = outter1()
f1()
print("global:",num)

# 4.
"""
Python中只有函数，模块和类才会引入新的作用域【在函数，模块和类中定义的变量，在外面无法直接访问】
其他的代码块，如：if，while，for，with...as  ,try-except等都不会引入新的作用域
"""

if 1:
    n = 4
print(n)

i = 0
while i < 3:
    m = 23
    i += 1
print(m)

for _ in range(5):
    a = 56
print(a)

2.局部变量和全局变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中

# 1.
num1 = 10    # 全局变量
def test():
    num2 = 20   # 局部变量


# 2.
n1 = 10     # 全局变量
def outter():
    n2 = 20   # 局部变量【函数作用域】
    def inner():
        n3 = 30   # 局部变量【局部作用域】
        print(n2,n3)
    return inner

# 注意：根据函数不同形式的定义，全局变量和局部变量不是绝对的

3.global和nonlocal

3.1global

# 【面试题】代码阅读题
# 1.两个不同的变量n，相互之间没有影响
n = 9
def check():
    n = 1
    print(n)   # 1
check()
print(n)    # 9


# 2,global  xx,声明xx变量是全局变量，全局和局部看到的是同一个变量，相互之间有影响
# n = 9
# def check():
#     n += 1   # n = n + 1
#     print(n)   # UnboundLocalError: local variable 'n' referenced before assignment
# check()
# print(n)

n = 9
def check():
    # 声明变量n来自于全局变量，则在函数中出现的n将不再是重新定义的新变量
    global n
    n += 1   # n = n + 1
    print(n)
check()
print(n)

3.2nonlocal

# 说明：nonlocal一般应用在闭包中，此处的local特指局部作用域

# 1.
x = 1
def outter():
    x = 2
    def inner():
        x = 3        # 定义了一个新的变量
        print("inner:",x)
    inner()
    print("outter:",x)
outter()
print("gloabl:",x)
"""
inner: 3
outter: 2
gloabl: 1
"""


# 2.
x = 1
def outter():
    x = 2
    def inner():
        # 声明x不是局部变量，而是来自于函数作用域内的变量
        nonlocal x
        x = 3    # 表示给x = 2中的x重新赋值
        print("inner:",x)
    inner()
    print("outter:",x)
outter()
print("gloabl:",x)
"""
inner: 3
outter: 3
gloabl: 1
"""

# 【面试题】代码阅读题
def outter():
    num = 23
    def inner():
        nonlocal  num
        if num == 3:
            num = 10
    inner()
outter()

# 【面试题】简述global和nonlocal的使用，并举例说明