lambda 表达式和匿名函数-eval()函数-递归函数-嵌套函数-nonlocal关键字（声明外部的局部变量）-LEGB规则

lambda 表达式和匿名函数
lambda 表达式可以用来声明匿名函数。lambda 函数是一种简单的、在同一行中定义函数的方法。lambda 函数实际生成了一个函数对象。
lambda 表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数的返回值。
lambda 表达式的基本语法如下：
lambda arg1,arg2,arg3… : <表达式>
arg1/arg2/arg3 为函数的参数。<表达式>相当于函数体。运算结果是：表达式的运算结果。
【操作】lambda 表达式使用

f = lambda a,b,c:a+b+c
print(f)
print(f(2,3,4))

g = [lambda a:a*2,lambda b:b*3,lambda c:c*4]
print(g[0](6),g[1](7),g[2](8))

执行结果

<function <lambda> at 0x0000000002BB8620>
9
12 21 3

eval()函数
功能：将字符串 str 当成有效的表达式来求值并返回计算结果。
语法： eval(source[, globals[, locals]]) -> value
参数：
source：一个 Python 表达式或函数 compile()返回的代码对象
globals：可选。必须是 dictionary
locals：可选。任意映射对象

#测试 eval()函数
s = "print('abcde')"
eval(s)

a = 10
b = 20
c = eval("a+b")
print(c)

dict1 = dict(a=100,b=200)

d = eval("a+b",dict1)
print(d)

执行结果

abcde
30
300

eval 函数会将字符串当做语句来执行，因此会被注入安全隐患。比如：字符串中含有删除文件的语句。那就麻烦大了。因此，使用时候，要慎重！！！

递归函数
递归函数指的是：自己调用自己的函数，在函数体内部直接或间接的自己调用自己。递归类似于大家中学数学学习过的“数学归纳法”。 每个递归函数必须包含两个部分：

1. 终止条件
   表示递归什么时候结束。一般用于返回值，不再调用自己。
2. 递归步骤
   把第 n 步的值和第 n-1 步相关联。
   递归函数由于会创建大量的函数对象、过量的消耗内存和运算能力。在处理大量数据时，谨
   慎使用。
   情况一函数内调用其他函数

#测试递归函数的基本原理
def test01():
    print("test01")
    test02()

def test02():
    print("test02")

test01()

执行结果

test01
test02

情况二函数内自己调用自己

#测试递归函数的基本原理
def test01():
    print("test01")
    test01()
    print("######")
def test02():
    print("test02")

test01()

执行结果

test01
test01
test01
test01
test01
test01#test01一直被调用，直到内存崩溃，这里不全部截取出来,后面的######也没有打印出来
RecursionError: maximum recursion depth exceeded while calling a Python object

情况三代值

#测试递归函数的基本原理
def test01(n):
    print("test01:",n)
    if n==0:
        print("over")
    else:
        test01(n-1)

def test02():
    print("test02")

test01(4)

执行结果

test01: 4
test01: 3
test01: 2
test01: 1
test01: 0
over
test01*** 0
test01*** 1
test01*** 2
test01*** 3
test01*** 4

【操作】 使用递归函数计算阶乘(factorial)
简单版

#使用递归函数计算阶乘
def factorial(n):

    if n==1:
        return 1
    else:
        return n*factorial(n-1)
result = factorial(5)
    print(result)

执行结果

120

复杂版

def factorial(n):
    if n==1:
        return 1
    else:
        return n*factorial(n-1)
for i in range(1,6):
print(i,'!=',factorial(i))

执行结果

1 != 1
2 != 2
3 != 6
4 != 24
5！=120

嵌套函数(内部函数)

def outer():
    print("outer running")
def inner01():
    print("inner running")
    inner01()
outer()

执行结果

outer running
inner01 running

上面程序中， inner01()就是定义在outer() 函数内部的函数。 inner01()的定义和调用都在outer()函数内部

一般在什么情况下使用嵌套函数？

1. 封装 - 数据隐藏
   外部无法访问“嵌套函数”。
2. 贯彻 DRY(Don’t Repeat Yourself) 原则
   嵌套函数，可以让我们在函数内部避免重复代码。
3. 闭包
   后面会详细讲解
   【操作】使用嵌套函数避免重复代码

def printChineseName(name,familyName):
    print("{0} {1}".format(familyName,name))
def printEnglishName(name,familyName):
    print("{0} {1}".format(name, familyName))

#使用 1 个函数代替上面的两个函数
def printName(isChinese,name,familyName):
    def inner_print(a,b):
        print("{0} {1}".format(a,b))
        
    if isChinese:
        inner_print(familyName,name)
    else:
        inner_print(name,familyName)

printName(True,"小七","高")
printName(False,"George","Bush")

执行结果

高 小七
George Bush

nonlocal关键字
nonlocal 用来声明外层的局部变量。
global 用来声明全局变量。
【操作】使用 nonlocal 声明外层局部变量

#测试 nonlocal、global 关键字的用法
a = 100
def outer():
    b = 10
    
    def inner():
        nonlocal b #声明外部函数的局部变量
        print("inner b:",b)
        b = 20

        global a #声明全局变量
        a = 1000
    
    inner()
    print("outer b:",b)

outer()
print("a：",a)

执行结果

inner b:10
outer b:20
a:  1000

LEGB 规则
Python 在查找“名称”时，是按照 LEGB 规则查找的：
Local–>Enclosed–>Global–>Built in

Local 指的就是函数或者类的方法内部
Enclosed 指的是嵌套函数（一个函数包裹另一个函数，闭包）
Global 指的是模块中的全局变量
Built in 指的是 Python 为自己保留的特殊名称。

如果某个 name 映射在局部(local)命名空间中没有找到，接下来就会在闭包作用域(enclosed)进行搜索，如果闭包作用域也没有找到，Python 就会到全局(global)命名空间中进行查找，最后会在内建(built-in)命名空间搜索 （如果一个名称在所有命名空间中都没有找到，就会产生一个 NameError）。

情况一Enclosed–>Global–>Built in

#测试 LEGB
str = "global" 
def outer():
    str = "outer" 
    def inner():
        str = "inner"
        print(str)
    inner()
outer()

执行结果

inner

Enclosed–>Global–

#测试 LEGB
str = "global" 
def outer():
    str = "outer" 
    def inner():
        #str = "inner"
        print(str)
    inner()
outer()

执行结果

outer

Global–>Built in

str = "global" 
def outer():
    #str = "outer" 
    def inner():
        #str = "inner"
        print(str)
    inner()
outer()

执行结果

global

Local–>Enclosed–>Global–>Built in

#str = "global" 
def outer():
    #str = "outer" 
    def inner():
        #str = "inner"
        print(str)
    inner()
outer()

执行结果

<class 'str'>