python 函数（提高篇）

匿名函数（最高复杂度到三元运算，不可加循环）

def change(a, b):
    return a**b


change(10, 2)

# 匿名函数
c = lambda x, y: x ** y

print(c(10, 2))
1
2
3
4
5
6
7
8
9
10

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数称之为高阶函数。（听起来好像不是我们印象中的哦，举个例子）

def get_abs(x):
    if x < 0:
        x = int(str(x).strip("-"))
    return x


def num(x, y, f):
    return f(x) ** f(y)


res = num(10, -2, get_abs)
print(res)
1
2
3
4
5
6
7
8
9
10
11
12

只要满足以下条件中的一个就可以称之为高阶函数：

接受一个或者多个函数的输入
return返回另外一个函数

嵌套函数

顾名思义就是函数的嵌套，下面举个简单的例子
请各位看官先看源码思考三个name分别会打印出什么，然后再看结果

name = "zhangsan"


def hello():
    name = "lisi"

    def hello1():
        name = "zhaosi"
        print("最里面的打印的是", name)

    hello1()
    print("第二层打印的是", name)


hello()
print("最外层打印的是", name)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

根据上面的结果，我们不难看出，即便是嵌套函数，参数也是遵循就近原则

函数的递归

def test1(x):
    print(x)
    x = int(x / 3)
    if x > 0:
        test1(x)
    print(x)


test1(999)
1
2
3
4
5
6
7
8
9

递归的特性：

必须要有一个明确的结束条件
每次进入更深一层递归时，问题规模相比上次递归都应有所减少
递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以递归调用的次数过多，会导致栈溢出，相当于程序崩溃！！！）

函数的闭包

函数内部嵌套函数即外部函数的作用域仍在被内部函数使用，并且内部函数返回自身

def a():
    name = "zhangsan"

    def b():
        print("打印外部的name变量", name)

    return b  # 返回是这个函数的内存地址


a()()  # 可以理解为 f = a( ) ,f( )就相当于是b( )
1
2
3
4
5
6
7
8
9
10

闭包的意义
返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域！！！

装饰器

通过高阶函数+闭包在不改变原有功能的前提下实现新功能，这里暂时先不讲，过于复杂回头我补充