python高阶函数

1、nonlocal 语句
　　作用:

　　　　告诉解释器，nonlocal声明的变量不是局部变量，也不是全局变量，而是外部嵌套函数内的变量

　　语法:
　　　　nonlocal 变量名1, 变量名2, ...

　　说明:
　　　　nonlcal 语句只能在被嵌套函数内部进行使用对nonlocal变量进行赋值将对外部嵌套函数作用域内的变量进行操作
　　　　当有两层或两层以上函数嵌套时，访问nonlocal变量只对最近一层变量进行操作
　　　　nonlocal 语句的变量列表里的变量名，不能出现在此函数的形参列表中

2、lambda 表达式

　　作用:

　　　　创始一个匿名函数对象

　　　　同 def 类似，但不提供函数名

　　　　语法格式:
　　　　　　lambda [函数形参列表]: 表达式

　　说明:
　　　　lambda 表达式创建的函数只能包含一条表达式
　　　　lambda 比函数简单且可以随时创建和销毁，有利于减少程序的偶合度

3、eval()和exec()函数

　　eval(source, globals=None, locals=None) 把一个字符串
　　　　source 当成一个表达式来执行，返回表达式执行后的结果
　　exec(source, globals=None, locals=None) 把一个字符串
　　　　source 当成程序来执行

4、函数式编程

　　函数式编程是指用一系列函数解决问题
　　　　说明:
　　　　用每一个函数完成细小功能，有系列函数的任意组合可以解决大问题
　　　　函数仅接收输入并产生输出，不包含任何能影响输出的内部状态

5、函数的可重入性:
　　当一个函数没有访问除局部变量以外的变量，则此函数为可重入函数

　　说明:
　　　　可重入函数，输入一定。结果必须一定

　　可重入函数：

　　　　def myadd(x, y):
　　　　　　return x + y
　　　　print(myadd(100, 200)) # 300
　　　　print(myadd(100, 200)) # 300

　　不可重入函数：

　　 　　s = 0

　　　　def myadd(x,y):

　　　　　　global s 

　　　　　　s += x +y

　　　　　　return s

　　　　print(myadd(100,200)) #300

　　　　print(myadd(100,200)) #600

6、高阶函数 High Order Function

　　什么是高阶函数:
　　　　满足下列条件之一的函数即为高阶函数
　　　　　　1. 函数接收一个或多个函数作为参数传入
　　　　　　2. 函数返回一个函数

　　map函数:
　　　　map(func, iter1, iter2, ....) # 返回一个可迭代对象，
　　　　　　此可迭代对象对iter1, iter2中的每一个元素计算得到结果并返回，当最短的一个函数结束时生成结束
　　参数说明:
　　　　func 对可迭代对象处理的函数，函数的参数个数必须与可迭代对象人个数相同
　　　　iter1, iter2, 为func提供数据，iter1, iter2, 可以有一个或多个，但至少要有一个

7、filter 函数

　　格式:
　　　　filter(func, iterable)
　　作用:
　　筛选可迭代对象iterable中的数据，返回一个可迭代对象，此可迭代对象只返回iterable提供的数据中满足条件的数据
　　说明:
　　　　func 含有一个形参的数据处理函数，此函数传入值为iterable中提供的数据，此函数func将对iterable中的每个元素进行求布尔值,返回True则保留此数据,返回False则将此数据丢弃
　　　　iterable 为可迭代对象，此可迭代对象提供的数据将传入到func进行判断后将定能否提供给调用者

8、sorted函数

　　作用:
　　　　将原可迭代对象的数据进行排序，生成排序后的列表
　　格式:
　　　　sorted(iterable, key=None, reverse=False)
　　说明:
　　　　iterable 可迭代对象
　　　　key 函数是用来提供一个值，这个值将作为排序的依据

　　　　reverse 标志用来设置是否降序排序

　　示例:
　　　　L = [5, -2, -4, 0, 3, 1]
　　　　L2 = sorted(L)
　　　　L3 = sorted(L, reverse=True)
　　　　L4 = sorted(L, key=abs) # L4=[0, 1, -2, 3, -4, 5]
　　　　L5 = sorted(L, key=abs, reverse=True)
　　　　names = ['Tom', 'Jerry', 'Spike', 'Tyke']
　　　　L6 = sorted(names) # ['Jerry', 'Spike', 'Tom', 'Tyke']
　　　　L7 = sorted(names, key=len) #['Tom', 'Tyke', ....]

　　注:
　　　　key绑定的函数的语法规则:
　　　　def getvalue(x):
　　　　　　return 依据
　　　　如:
　　　　　　names = ['Tom', 'Jerry', 'Spike', 'Tyke']
　　　　　　def get_key(x):
　　　　　　　　print("x=", x)
　　　　　　　　return len(x)

　　　　　　L8 = sorted(names, key=get_key)

　　函数直接或间接的调用自身

　　示意:
　　　　直接调用自身:
　　　　　　def f():
　　　　　　　f()
　　　　　　f()
　　　　间接调用自身:
　　　　　　def fa():
　　　　　　　fb()
　　　　　　def fb():
　　　　　　　fa()
　　　　　　fa()

　　递归说明：
　　　　递归一定要控制递归的层数，当符合某一条件时要终止递归调用几乎所有的递归都能用while循环来代替
　　实现方法:
　　　　先假设此函数已经实现
　　递归的优缺点:
　　　　优点:
　　　　　　递归可以把问题简单化，让思路使为清淅，代码更简洁
　　　　缺点:
　　　　　　递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果

　　示例:
　　递归求和:
　　　　def mysum(n):
　　　　　'''返回0 + 1 + 2 + 3 + 4 + ..... + n 的和'''
　　　　　if n == 0:
　　　　　　return 0
　　　　　return n + mysum(n-1)

　　　　print(mysum(100)) # 5050
　　　　print(mysum(900)) # 没错
　　　　print(mysum(1000)) # 程序崩溃