四、匿名函数/内置函数/递归/闭包

高阶函数：一个函数作为参数，传入另一个函数

一、匿名函数 

lambda表达式：简化函数的书写形式，适用于短小的函数 

lambda 参数1，参数2：返回值

等价于：

def 函数名（参数1，参数2）：

　　return 返回值 

def f(x):
　　return x+1

g = lambda x : x+1 # 简化代码，x表示参数，x+1表示返回值

print(f(1))
print(g(1))

 举例：

def sort_test():
    students=[
        {'name':'zjx','age':19},
        {'name':'huahua','age':14}
        {'name':'乐乐','age':31}
    ]
    print(sorted(setudents,key=lamdba student:student['age']))   
    print(sorted(setudents,key=lamdba student:student['age'],reverse='Ture')) 

二、内置函数

1：Map

功能：根据提供的函数对指定序列做依次映射 

map() 函数语法：map(function, iterable,...) 

• function -- 函数
• iterable -- 一个或多个序列

举例1：

def add_list(list1,list2,list3):
    return list(map(lambda x,y,z: x+y+z, list1,list2,list3 ))


if __name__ == '__main__':
    print(add_list([1,2,3,4],[2,3,4,5],[3,4,5,6])) # [6, 9, 12, 15]

注意：map函数的第一个参数是一个函数名，如果函数的实现比较简单的时候，可以用匿名函数--lambda

2.reduce函数

功能：会对参数序列中元素进行累积,reduce()方法接受一个function作为累加器，sequence中每个值（从左到右）开始缩减，最终计算为一个值

举例：

def add(x,y):
    return x + y

print(reduce(add,range(1,101))  # 累加1+2+3....+100
print(reduce(lambda x,y:x+y,range(1,101)))

3.filter

filter 函数 可迭代对象

功能：过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表 

filter()语法：filter(function, iterable) 

• function -- 判断函数。
• iterable -- 可迭代对象。

接收两个参数，第一个为函数名，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中

 

 举例：

def f(x):
    if x > 5:
        return x
print(list(filter(f,[11,2,33,4,5])))
print(list(filter(lambda x: x > 5, [11,2,33,4,5]))) 

 4.zip

功能：zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，返回的是一个zip对象

 

举例

def zip_fun():
    A = ["a","b","c"]
    B = [1, 2, 3]
    print(zip(A,B))       # <zip object at 0x0000027C5D32D8C8> 
    print(isinstance(zip(A,B),Iterator))   #True
    for item in zip(A,B):
        print(item)      # 依次输出 ('a', 1)  , ('b', 2)  ,('c', 3)  

    print(list(zip(A,B)))  # [('a', 1), ('b', 2), ('c', 3)]

if __name__ == '__main__':
    zip_fun() 

三、递归

递归:函数在运行的过程中调用自己,如下图所示。

构成递归的条件：

• 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
• 必须有一个明确的递归结束条件
• 递归调用的表达式

递归深度：最大递归次数

import sys
sys.setrecursionlimit(1000)  # 表示递归深度为1000，即只能递归1000次  

举例1：

def f(x=100):
    if x == 1:    # 递归结束的条件
        return 1  # 递归结束
    return f(x-1) + x    # 递归调用

if __name__ == '__main__':
    print(f())  #累加1+2+3....+100=5050

举例2：

# 一个小球从100米高度自由落下，每次落地后反跳会原来的高度的一半再落下，求在第十次落地时，共经过多少米？用递归实现

def f(n, h=100):
    if n == 1:
        return h
    return f(n-1) + h/2**(n-1) * 2

举例3：

# 200元买200本书，A类5元一本，B类3元一本，C类1元2本，有多少种买法？
# 思路：先明确200元钱单独买每类书，可以买多少本，再进行for循环嵌套，最后输出符合条件的即可

def buy_book():
    money = 200
    nums = 200
    count = 0  # 记录买法的种类

    for a in range(int(money/5) + 1):
        for b in range(int(money/3) + 1):
            for c in range(int(money/0.5) + 1):
                if 5 * a + b * 3 + c * 0.5 <= 200 and a + b + c ==200:
                    count += 1
    return count

四、闭包

闭包：函数可以作为参数传给另一个函数

def outer():
    result = 0  # local变量 局部变量
    def inner():
        nonlocal result
        result += 1
        print(f"result的值{result}")
    return inner  # 把函数返回

if __name__ == '__main__':
    f = outer()
    f()   # result的值1
    f()   # result的值2
    f()   # result的值3

包：一个函数包着另外一个函数

闭：用函数中的函数来操作函数中的变量。（操作函数中的局部变量的一种方法）

好处：上次的操作状态被保存下来（保存函数中某个变量的值）。如上例中，执行多次f()，查看结果

闭包是一种编成思想，其他语言也有，如JavaScript