一、lambda表达式（又名匿名函数表达式） ‘ λ ’
作用：
创建一个匿名函数对象
同def类似，但不提供函数名
语法:
lambda [形参1，形参2，…] : 表达式
[形参] ：形参列表可以有，也可以没有
表达式的返回值讲作为函数的返回值
示例：
def myadd(x,y):
return x+y
可以改写为：
myadd = lambda x,y : x +y
没名怎么用？可以用一个变量绑起来，也可以不绑，和def定义的函数区别就是lambda不给变量绑定。
示例：
>>> #可以用一个变量和lambda表达式绑定起来
>>> myadd =lambda x,y : x+y
>>> myadd
<function <lambda> at 0x000002A031F53510>
>>> myadd(100,200)
300
>>> print(myadd(99,99))
198
>>> #将表达式得到的结果对应的对象返回回来
>
#调用的时候和def定义的函数一致
# 列表、元组、字典中、函数、函数的形参存的都是变量的引用关系
下面的def定义的函数与上面的lambda表达式等价：只有一些细微的差别
def myadd(x,y):
return x+y
#x+y生成一个对象， 然后return将这个对象的地址返回回去
语法说明：
lambda只是一个表达式，它用来创建一个函数对象
当lambda表达式调用时，先执行冒号后面的表达式，并返回表达式的结果的引用
lambda表达式创建的函数只能包含一条表达式
lambda比较简单，且可以随时创建和销毁，有利于减少程序的耦合度
练习：
1.写一个lambda表达式，判断这个数的三次方再加5能否被5整除，如果能整除返回True
fun = lambda x : (x**3+5)%5 == 0
print(fun(2))
print(fun(5))
执行结果：
False
True
2.写一个lambda表达式，求俩个变量的最大值：
mymax = lambda x,y : x if x>y else y
v = mymax(99,88)
print(v)
print(mymax(55,66))
执行结果：
99
66
二、eval()和 exec()函数：
eval函数：
作用：
把一个字符串当成一个表达式执行，返回表达式执行后的结果
格式：
eval(source,global = None ,locals = None)
示例1：
x = 100
y = 200
s = 'x*y'
print(eval(s))
执行结果：
20000
示例2：
s = "list(range(10))"
print(eval(s))
执行结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
exec函数：
作用：
把一个字符串当程序来执行
格式：
exec(source , globals = None,local = None)
示例：
s = 'x = 100;print("hello");x+=1;print(x)'
print(s)
exec(s)
执行结果：
x = 100;print("hello");x+=1;print(x)
hello
101
#其实我们写的python代码都是字符串，最终我们用python中的exec来把文件中的函数跑一遍
练习：写一个程序，解释执行用户输入的任何语句
while True:
s = input("请输入语句 $ >>> ")
if s == "bye":
break
exec(s)
四、函数式编程
是指用一系列函数解决问题
“函数是一等公民”
1.灵活性，函数本身是对象，可用变量将其绑定
2.函数可做参数传入到另一个函数
3.函数可做另一个函数的返回值
函数式编程的好处：
1.每一个函数完成细小的功能，一系列函数的任意组合可以解决大的问题
2.函数仅接收输入并产生输出，不会影响其他全局变量的状态
（IPO编程）i： input 输入 p ：process算法 o：output 输出
举例：三个函数组合完成
求1+2+3+4+…+n的和：
print(sum(range(n+1)))
练习：求1+1/2+1/4+1/8+…+1/2**n
x = 100
print(sum([ (1/(2**x)) for x in range(0,x+1) ]))
执行结果：
2.0
#这是一个极限值
五、高阶函数 High Order Function
什么是高阶函数：满足下列函数中的一个的函数即为高阶函数
1.函数接收一个或多个函数作为参数传入
2.函数返回一个函数
python内置（builtins）的高阶函数：
map filter sorted
map函数：
map（func,*iterables）:用函数对可迭代对象中的每一个元素作为参数计算出新的可迭代对象（处理加工后产生的map类型的对象），当最短的一个可迭代对象不再提供数据时（短板效应）,此可迭代对象生成结束
即就是：将可迭代对象中的原始数据送到fun函数中”加工处理“，然后再依次返回回来
map返回回来是一个可迭代对象，map类型的对象
示例：生成一个可迭代对象，要求此可迭代对象可以生成1~9自然数的平方
1,4,9,16,…,81
def power2(x):
return x**2
for x in map(power2,range(1,10)):
print(x,end = ' ')
执行结果：
1 4 9 16 25 36 49 64 81
执行过程：
示例:求以上数据的和
print(sum(map(power2, range(1, 10))))
执行结果：
285
示例：当参数有多个可迭代对象的俩个实例
先看一下我们常用的内建函数pow(x,y,z = None)定义：
pow(x, y, z=None, /)
Equivalent to xy (with two arguments) or xy % z (with three arguments)
1.
#生成一个可迭代对象，要求此可迭代对象生成
# 1**4 2**3 3**2 4**1
# 1 8 9 4
for x in map(pow,[1,2,3,4],[4,3,2,1]):
print(x)
执行结果：
1 8 9 4
分析如图：
2.我们再来理解一下这句话“当最短的一个可迭代对象不再提供数据时（短板效应）,此可迭代对象生成结束”
for x in map(pow,[1,2,3,4],[9,8,7,6,5,4,3,2,1]):
print(x,end =" ")
执行结果：
1 256 2187 4096
解析：
练习：
1.求 1** 2 + 2** 2 + 3** 2 +…+9** 2的和
3. 求1 ** 9 + 2 ** 8 + 3** 7 +…+9 ** 1的和
def fun2(x):
return x**2
def fun3(x,y):
return x**y
#求 1**2 + 2**2 + 3**2 +.....+9**2的和
for x in map(fun2,range(1,10)):
print(x,end = " ")
#也可以改写成lambda表达式
#mysum = (sum(map(lambda x : x **2,range(1,10))))
print ()
#求1**9 + 2**8 + 3**7 +.....+9**1的和
for i in map(fun3,range(1,10),range(9,0,-1)):
print(i,end = " ")
执行结果：
1 4 9 16 25 36 49 64 81
1 256 2187 4096 3125 1296 343 64 9
filter函数：
格式：
filter(func , iterable)
作用：
筛选可迭代对象iterable中的数据，返回一个可filter类型的迭代对象，此可迭代对象就是对iterable进行筛选得到的元素进行存储
函数func将对可迭代对象iterable中每个元素进行求值筛选，返回False时将此数据丢失，返回Truej将保留该数据
实例：
#isodd 函数判断x是否为奇数，是奇数返回True
def isodd(x):
return x % 2 == 1
#找出1~100之间的奇数，并打印
for i in filter(isodd,range(1,101)):
print(i,end = " ")
执行结果：
1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99
#生成100以内所有偶数的列表，用filter表示
#方法一
L = [x for x in range(10) if x%2 == 0]
print(L)
#方法二
L = []
def iseven(x):
return x % 2 == 0
for i in filter(iseven,range(1,100)):
L.append(i)
print(L)
#方法三：
L = [x for x in filter(lambda x : x%2 == 0,range(0,100))]
执行结果：
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98]
sorted函数：
作用：
将原来的可迭代对象的数据进行排序，生成排序后的列表并返回
格式：
sorted(iterable , key = None,reverse = False)
参数说明：
iterable 可迭代对象
key 绑定函数，此函数用来提供一个排序的依据
reverse 标志用来设置是否降序排序（从大到小）
示例：
L0 =[1,99,2,-2,4,0,7]
#默认从小到大
L1 = sorted(L0)
#从大到小
L2 = sorted(L0,reverse = True)
print(L1)
print(L2)
执行结果：
[-2, 0, 1, 2, 4, 7, 99]
[99, 7, 4, 2, 1, 0, -2]
示例：说明key的用处
比如说：我们人按照从小到大的顺序排列，而年龄就是我们排序的依据key，最终交换顺序的还是我们人
L = [5,-2,-4,0,3,1]
#依据绝对值：5 2 4 0 3 1
排完： 0 1 -2 3 -4 5
函数：abs() 将每个元素放在abs中执行依次
#key的用处
L0 =[1,99,2,-2,4,0,7]
L3 =sorted(L0,key = abs)
print(L3)
执行结果：
[0, 1, 2, -2, 4, 7, 99]
练习：将一组人的名字进行排序，以名字的长度作为依据。
L = ["MIKE","TOM","JRRRY","HUXIAOYU"]
L1 = sorted(L,key = len)
print(L1)
执行结果：
['TOM', 'MIKE', 'JRRRY', 'HUXIAOYU']
#以字符串反转后的字符串作为依据
def fr(s):
return s[::-1]
L = ["MIKE","TOM","JRRRY","HUXIAOYU"]
L2= sorted(L,key = fr)
print(L2)
运行结果：
['MIKE', 'TOM', 'HUXIAOYU', 'JRRRY']