递归和lambda表达式，高阶函数

递归（简单理解）

• 特点
  • 函数内部自己调用自己
  • 要有出口

1. 3以内的数值之和：

# 3 + 2 + 1
def sum_numbers(num):
    # 1.如果是1，直接就返回1 --出口
    if num == 1:
        return 1
    # 2. 如果不是1，重复执行累加并返回结果
    return num + sum_numbers(num-1)

sum_result = sum_numbers(3)
print(sum_result) # 6

2. 如果递归没有出口，会报错：超出最大递归深度（深度因电脑所异）

汉诺塔问题

lambda表达式

如果一个函数有一个返回值，并且只有一句代码，可以使用；lambda表达式，对于服务器来说可以节省空间
又名匿名函数
不适合大型项目

lambda的语法

• lambada 参数列表： 表达式

lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用
lambda表达式能接收任何数量的参数，但只能返回一个表达式的值！

def fun1():
    return 100
print(fun1) # <function fun1 at 0x00000000021D5158>
print(fun1()) # 100

# lanbda表达式
fun2 = lambda: 200
print(fun2) # <function <lambda> at 0x00000000021D51E0>
print(fun2()) # 200

# 计算a+b
def add(a, b):
    return a+b

result = add(1, 2)
print(result) # 3

# lambda实现
fun1 = lambda a, b :a+b
print(fun1(1,3)) # 4

lambda的参数形式

无参数

fn1 = lambda: 100
print(fn1()) //100

一个参数

fn1 = lambda a: a
print(fn1('hello world!'))//hello world!

默认参数（缺省参数）

fn1 = lambda a, b, c=100: a+b+c
print(fn1(10, 20)) //130

默认参数写了就覆盖，不写就用默认的值

可变参数：*args

fn1 = lamdba *args: args
print(fn1(10, 20, 30))// (10, 20, 30)

返回值是一个元组

可变参数：**kwargs

fn1 = lambda **kwargs：kwargs
print(fn1(name='pthon', age=20))//{name='python', age=20}

返回的是一个字典

lambda的应用

带判断的lambda

fn1 = lambda a, b: a if a > b else b
print(fn1(1000, 500))//1000

列表数据按字典key的值排序

students = [{'name':'Tom', 'age': 20},{'name':'Rose', 'age': 19},{'name':'Jack', 'age': 22}]
# 按name的值升序排序
students.sort(key=lambda x: x['name'])
print(students)
# 按name的值降序排序
students.sort(key=lambda x: x['name'], reverse=True)
print(students)
# 按age的值升序排序
students.sort(key=lambda x: x['age'])
print(students)

运行结果

高阶函数

把函数作为参数传入，这样的函数称为高阶函数。
高阶函数就是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式

体验高阶函数

1. abs(num)：对数字求绝对值的计算
2. .round(num)：可以完成对数字的四舍五入的计算
3. 可以把内置函数当作参数传入，abs和round随意

def sum_num(a, b, f):
    return f(a)+f(b)

result = sum_num(-1, -2,abs)    # 传入函数时，不要加上小括号，那代表执行
print(result)   #3

4. 代码较为简洁，灵活性更高
5. 函数式编程大量使用函数，减少代码的重复，因此程序比较短，开发速度较快

内置高阶函数

map()

map(function, list)，将传入的函数变量function作用到lst变量的每个元素中，并将结果组成新的列表（Python）或迭代器（Python3）返回；
示例：

# map函数是把传入的函数作用到变量上
list1 = [1, 2, 3, 4, 5]
def fun1(x):
    return x **2
result = map(fun1, list1) # 变量类型是map -- <class 'map'>
print(result) # <map object at 0x0000000001EB7860>
print(type(result)) # <class 'map'>
print(list(result)) # [1, 4, 9, 16, 25]

reduce()

reduce(func, lst)，其中必须要有两个参数，每次fun计算的结果继续和序列的下一个y元素做累积计算。
reduce传入的参数必须接收两个参数
import functools 导入模块

import functools
# 使用reduce函数，需要先导入模块functools，
# 作用是把函数计算的结果与下一次计算的结果相加
list1 = [1, 2, 3, 4, 5]
def func(a, b):
    return a+b
result = functools.reduce(func, list1)
print(result) # 15

filter()

filter(fuc,list)函数用于过滤序列，过滤不符合条件的元素，返回一个filter对象，若想转换为列表对象，就用list()l来转换

# filter函数，用于过滤数据，所以传入的函数，最好返回条件
# 返回一个filter类型对象
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def fun(x):
    return x % 2 ==0
result = filter(fun, list1)
print(result) # <filter object at 0x000000000273AA58>
print(list(result)) # [2, 4, 6, 8, 10]