Python函数中几个比较重要内容，给大家梳理一下----闭包原理（一）

一.函数嵌套的作用

1. 简单介绍作用域的分类

# ------------作用域分类--------------

# 1.全局作用域：

# 在整个程序运行环境中可见

# 全局作用域中的变量称为全局变量

# 2.局部作用域：

# 在函数，类等累不可见

# 局部作用域中的变量称为局部变量，其使用范围不能超过其所在局部作用域

# 也称为本地作用域local

# 一般来说外部作用域变量可以在函数内部可见，可以使用

# 反过来，函数内部的局部变量，不能在函数外部看到

2. 函数作用域（重要性）

# 一个标识符的可见范围，这就是标识符的作用域，一般常说的是变量的作用域

简单介绍一下概念，来一串代码（本人手写的）

防止有人看不懂，手敲一下代码（简单写一下）

def outer():
    o = 65    #-----局部变量

    def inner():
        o = 0x61    #97----ASCLL码表  #----局部变量（如不会可以看一ASCLL码表，一一对应即可）
        print(1, o, chr(o))

    print(2, o, chr(o))
    inner()           
    print(3, o, chr(o))


print(outer())
#第一次执行-------print(2, o, chr(o))------2，65，A
#第二次执行-------print(1, o, chr(o))------1，97, a
#第三次执行-------print(3, o, chr(o))------3，65，A

2赋值问题

先来一串代码（本人手写）

接着手敲代码

x=300
def foo()
  y=x+1    #出错
  print(y)
  x=500    #在python赋值即定义---因为上面x没有定义，在下面定义x，所以此代码运行不出来
  print(x)

print(foo())

这上面代码运行不出来

接下来再看一个例子，接着分析

x=300
def foo():
   x+=1   #x=x+1------x被赋值，所以是本地变量，运行不出来
   print(x)

print(foo())#-----调用

这上面代码运行不出来

改成这样即可：

x=300
def foo():
   x=2
   print(x)

print(foo())

2global问题

简单介绍一下概念：

# global关键字的变量，将foo内的x声明为使用外部的全局作用域中定义的x

# 全局作用域中必须有x的定义

# 注意：使用了global，foo中的x不再是局部变量了，它是局部变量。

# global使用原则：

# 1.外部作用域变量会在内部作用域可见，但也不要在这个内部的局部作用域中直接使用，因为函数的目的就是为了封装，尽量与外界隔离

# 2.如果函数需要使用外部局部变量，尽量使用函数的形参定义，并在调用传实参解决

# 3.不用global，学习它就是为了深入理解变量作用域

接着来一串代码（本人手写）

接着手敲代码

x=600
def foo():
  global x   #x这个标识被修饰，被global声明成了全局变量。这串代码可以运行出来
  x+=1
  print(x)

print(foo())

上面的赋值问题也可以用global（建议少用）

重点来了闭包原理

3.闭包原理：未在本地作用域中定义的常量。例如：定义在内层函数外的外层函数的作用域中的变量。

闭包：就是一个概念，出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就形成了闭包。

先来一串代码，先分析一下，更加明确（本人手写）

接着手敲代码

def counter():
    c = [0]

    def inner():
        c[0] += 1
        return c[0]

    return inner


foo = counter()
print(foo())   #1
print(foo(),foo())   #2,3
# 首先先运行的是counter(),让两个标识符（c,inner)都消亡了
# foo()由于外层函数运行结束了，内层函数没有消亡，什么时候被调用不知道，但是内层函数要用到外层函数的自由变量（c)
#所以可以得出print(foo())------1

接下来这串代码要注意（相似）

def counter():  # python3中比较简单实现闭包的方式
    c = 0
    def inc()
        c += 1  # c=c+1#如果在一个函数中使用c=,c就是inc函数局部变量
        return c
    return inc
foo=counter()
print(foo())-----------运行不出来-----上面一串代码是列表，这一处赋值即定义（c=c+1)

如果向让上面这串代码运行出来，有两种方法

1. global(不推荐）

def counter():  # python3中比较简单实现闭包的方式
    global c  #用global,让c成为全局变量
    c = 0
    def inc()
        global c     #所以得出c=0，c有值了
        c += 1  # c=c+1#如果在一个函数中使用c=,c就是inc函数局部变量
        return c
    return inc
foo=counter()
print(foo())#---------此处能够运行出来

用接下来的方法介绍一下nonlocal

nonlocal:将变量标记为不在本地作用域，而是在上级的某一级局部作用域中定义，但不能是（全局作用域----全局变量）中定义

2.nonlocal（推荐）

def counter():  # python3中比较简单实现闭包的方式
    c = 0
    def inc()
        nonlocal c     #从定义中的函数找出c=0（就近原则），不能找全局变量。
        c += 1  # c=c+1#如果在一个函数中使用c=,c就是inc函数局部变量
        return c
    return inc
foo=counter()
print(foo())#---------此处能够运行出来

这是以上函数几个比较重要的内容，尤其是这个闭包原理，大家需要认真的去分析。

如有错误，希望大家指出来。