day12-递归与高阶函数

一、递归

# 衔尾蛇

# 递归特点
# 1,函数内部调用自己
# 2,必须要有出口

实例1：# 有规律循环

打印1-9

def func(start, stop):
    print(start)  # 9
    if start == stop:  # 结尾 递归的出口
        return    # 结束函数运行，停止递归

    func(start + 1, stop)  # 自己调用自己

func(1, 9)

1
2
3
4
5
6
7
8
9 

加入步长

def func(start, stop, step=1):
    print(start)  # 9
    if start == stop:  # 结尾 递归的出口
        return

    func(start + step, stop, step)  # 自己调用自己


func(1, 9, 2)

1
3
5
7
9

实例2：# 无规律循环

list_data = [1, [2, 3, [4, 5, 6, [7, 8, 9, [0]]]]]

def func(data):
    if type(data) == list:
        for i in data:
            func(i)
    else:
        print(data)


func(list_data)

1
2
3
4
5
6
7
8
9
0

二、lambda表达式
1、lambda 匿名 #匿名函数  没有名字的函数
2、优点 节省内存空间 优化代码
3、当函数里面的代码只有一行 可以转换为匿名函数

def add(a, b): return a + b 

(lambda a, b: a + b)(1, 2)
# print(add(1, 2))

add1 = (lambda a, b: a + b)  # 定义名字，重复使用
print(add1(1, 2))
print(add1(2, 3))

# 实际中，只使用一次 不需要考虑函数的名字，只需要功能
# lambda 传入的参数：返回的数据

#实例 5!=5x4x3x2x1
def func(data):
    if data == 1:
        return 1  # 出口
    return data * func(data - 1)

print(func(5))
# func(5) 5xfunc(4)
# func(4) 4xfunc(3)
# func(3) 3xfunc(2)
# func(2) 2xfunc(1)
# func(1) 1

三、高阶函数
1、函数调用另外一个函数
2、高阶函数自带了for循环，变成了一个生成器对象
3、map 映射（列表推导式可以代替）

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
def int_to_str(data):
    return str(data)
print(list(map(int_to_str, list1)))

print(list(map(lambda i: str(i), list1)))  # 生成器对象 0秒钟
print(list(map(str, list1)))

 4、reduce 减，对列表中的两个数据进行操作，不能对3个数进行操作

from functools import reduce  # from 从什么地方 import 导入什么东西

list2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(reduce(lambda a, b: a + b, list2))    # 45

 

list3 = [[1, 2], [3, 4], [4, 6]]

def aa(a, b):
    # a[1] + b[1] if type(a) == list else a + b[1]    #三元表达式

    if type(a) == list:
        return a[1] + b[1]
    else:
        return a + b[1]

print(reduce(aa, list3))    # 12
print(reduce(lambda a, b: a[1] + b[1] if type(a) == list else a + b[1], list3))  # lambda表达式

 

 

其他：

1、  高阶函数定义：
1）  一个函数作业参数传给另外一个函数
2）  一个函数的返回值为另外一个函数
3）  函数返回值为该函数本身，则为递归

2、  内置高阶函数
1）  map()函数
参数：一个函数+一个序列
功能：将序列中的值处理再依次返回至列表内
返回值：为一个迭代器对象
2）  filter()函数
参数：一个函数+一个序列
功能：过滤
返回值：迭代器对象
3）  reduce函数
参数：函数+可迭代对象
返回值：一个值，而不是迭代器对象
常用于叠加、叠乘
需要from functools import reduce
3、  在函数体中，又有一个完整的函数体，叫嵌套
4、  循环=递推
5、  递归的核心：
1）  算法：自己调用自己
2）  两部分：递推+回归   先递推，再回归
3）  递归只是一种思想，能用递推解决的都可以用递归实现
4）  重复的去调用
5）  缺点：占用内存多，导致内存泄漏
6、lambda  参数：函数体返回的值  判断（可加可不加）