7.匿名函数、函数作用域、递归函数、闭包

      匿名函数       

filter(lambda x: x>10, li)

语法规则： lambda 参数 : 表达式

简单的函数，可以不用使用def定义一个函数，使用匿名函数即可

函数调用，类似于filter、map等函数里面，可以使用匿名函数来处理

提高开发效率，匿名函数的合理利用能够让那个代码更加简洁

print((lambda x,y:x+y)(11,22))

33

f = lambda x,y:x+y
print(f(11,22))

33

li = [1,3,34,2,4,6,86,4,4]
# def func(n):
#     if n>4:
#         return n
aa = filter(lambda n:n>4,li)
print(list(aa))

[34, 6, 86]

    函数作用域     

一、示例

外部不能访问函数内部变量：

def func():
    a = 222   #局部变量
    print('函数里边:',a)
    return a
func()
print('函数外面：',a)

函数里边: 222
Traceback (most recent call last):
  File "/home/pyvip/projects/home/pyvip/projects/基础班/复习.py", line 7, in <module>
    print('函数外面：',a)
NameError: name 'a' is not defined

函数里面不能修改函数外部变量:

a = 11        #全局变量
def func():
    # global a
    a += 1  #局部变量
    print('函数里边:',a)
    return a
func()
print('函数外面：',a)

  File "/home/pyvip/projects/home/pyvip/projects/基础班/复习.py", line 7, in <module>
    func()
  File "/home/pyvip/projects/home/pyvip/projects/基础班/复习.py", line 4, in func
    a += 1  #局部变量
UnboundLocalError: local variable 'a' referenced before assignment

函数内部能够访问函数外部变量：

a = 11        #全局变量
def func():
    # a = 222   #局部变量
    print('函数里边:',a)
    return a
func()
print('函数外面：',a)

函数里面和函数外部变量名相同：

a = 11        #全局变量
def func():
    a = 222   #局部变量
    print('函数里边:',a)
    return a
func()
print('函数外面：',a)

函数里边: 222
函数外面： 11

二、global 和 nonlocal

1.global 

a = 11        #全局变量
def func():
    global a         #声明a是个全局变量
    a += 1  #局部变量
    print('函数里边:',a)
    return a
func()
print('函数外面：',a)

函数里边: 12
函数外面： 12

2.nonlocal

a = 11        #全局变量
def func():
    # global  a         #声明a是个全局变量
    a = 666  #局部变量
    print('外层函数func:',a)
    def fun1():
        nonlocal a                 #声明a的修改对外层函数有效
        a = 999
        print('内层函数fun1:,a)
    fun1()
func()
print('函数外面：',a)

外层函数func: 666
内层函数fun1: 999
函数外面： 11

     递归函数       

 递归中可以函数自身调用自身，但是使用时类似于条 件循环一样，要有递归的终止条件

使用递归时，常常可以让代码更加简洁 递归会占用比较多的内存，当递归次数比较多时，性能就会降低， 因此不建议多使用递归

def fun(n):
    if n==1:
        return n
    else:
        return n*fun(n-1)

a = fun(6)
print(a)


720

          闭包           

闭包是函数里面嵌套函数，外层函数返回里层函数，这种情况称之为闭包 闭包是概念，不是某种函数类型，和递归的概念类似，就是种特殊的函数调用 闭包可以得到外层函数的局部变量，是函数内部和函数外部沟通的桥梁，大多数时候和和装饰器一起使用

一、内嵌函数

def fun():

    def fun1():
        print('嵌套的内层函数')
    print('-----调用了fun-----')

    return fun1

result = fun()
print(result)

二、闭包

def fun1():
    a = 1
    def fun2():                                #1.函数里边嵌套一个函数
        print('=====fun2=======',a)            #2.外层函数返回的是内层函数的函数名
    return fun2                                #3.内层函数有引用外层函数的变量

a = fun1()
a()


=====fun2======= 1