python（22）- 递归和函数式编程

递归：

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

1. 必须有一个明确的结束条件；

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少；

3.递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

age(5)=age(4)+2
age(4)=age(3)+2
age(3)=age(2)+2
age(2)=age(1)+2
age(1)=10
n==1    age(n)=10
n>1     age(n)=age(n-1)+2

递归方法实现

def age(n):
    if n==1:
        return 10
    else:
        return age(n-1)+2

print(age(5))
---->18

　

递归函数格式

def func(n):
    if n == 10:
        return
    print('from func')
    func(n-1)

func(10)

递归效率低，python3中栈默认次数为1000次，可以设栈的次数

import sys
sys.setrecursionlimit(10000)

递归函数应用

用二分法查看整型在不在data列表中

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]

程序如下

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
def search(num,data):
    print(data)
    mid_index=int(len(data)/2)
    mid_value=data[mid_index]
    if num>mid_value:   #num在data中值右侧
        data=data[mid_index:]
        return search(num,data)
    elif num<mid_value:   # num在data中值右侧
        data=data[:mid_index]
        return search(num, data)
    else:
        print("find it!")

search(35,data)
--->[1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
    [18, 20, 21, 22, 23, 30, 32, 33, 35]
    [23, 30, 32, 33, 35]
    [32, 33, 35]
    [33, 35]
    find it!

search(3,data) 
--->[1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
    [1, 3, 6, 7, 9, 12, 14, 16, 17]
    [1, 3, 6, 7]
    [1, 3]
    find it!

search(19,data) 
---->报错，一直在寻找19，查了1000次后栈满，所以报错

程序优化版

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
def search(num,data):
    print(data)
    if len(data) > 1:
        mid_index=int(len(data)/2)
        mid_value=data[mid_index]
        if num>mid_value:   #num在data中值右侧
            data=data[mid_index:]
            return search(num,data)
        elif num<mid_value:   # num在data中值右侧
            data=data[:mid_index]
            return search(num, data)
        else:
            print("find it!")
    else:
        if data[0]==num:
            print("find it!")
        else:
            print(num,"不在data列表中")

search(19,data)
---->[1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
    [18, 20, 21, 22, 23, 30, 32, 33, 35]
    [18, 20, 21, 22]
    [18, 20]
    [18]
    19 不在data列表中

　　

函数式编程：

1.不会修改外部状态

2.函数式编程语言非常精简，可读性比较差

3.模仿数学意义上的函数编程

高阶函数：map , reduce ,filter,sorted

能把函数作为参数传入，这样的函数就称为高阶函数。

匿名函数:  lambda

面向过程编程：我们通过把大段代码拆成函数，通过一层一层的函数，可以把复杂的任务分解成简单的任务，这种一步一步的分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

函数式编程：是使用一系列函数去解决问题，函数式编程就是根据编程的范式来，得出想要的结果，只要是输入时确定的，输出就是确定的。