递归：

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

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

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

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

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

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