函数式编程
Lambda表达式（匿名函数）
函数体相对简单，仅仅是一个表达式。
- 以lambda开头
- 紧跟参数后用冒号与表达式隔开
- 只是一个表达式
简化一些弱函数…
lam = lambda x: 100 * x
lan(89)
lam2 = lambda x, y, z: x + y * 10 + z * 100
lan2(4, 5, 6)
----------
8900
654
Zip函数（numpy包）
将两个可迭代列表归并为一个可迭代的tuple元素序列。
将列表各项元素合并，并存入tuple
import numpy as np
lst1 = [i for i in range(10)]
lst2 = [i*2 for i in lst1]
tp = zip(lst1, lst2)
for i in tp:
print(i,end=" ")
-----------
(0, 0) (1, 2) (2, 4) (3, 6) (4, 8) (5, 10) (6, 12) (7, 14) (8, 16) (9, 18)
-----------
Enumerate函数
将迭代对象赋予一个索引，并将元素内容与索引打印成tuple
start起始索引参数
l1 = [i for i in range(10)]
#可设置起始索引 start
em = enumerate(l1)
print(type(em))
for i in em:
print(i, end = ' ')
-------
<class 'enumerate'>
(0, 0)(1, 1)(2, 2)(3, 3)(4, 4)(5, 5)(6, 6)(7, 7)(8, 8)(9, 9)
-------
Map函数（映射列表元素）
简化一些弱循环
def maps(n):
return n* 10
li = [i foe i in range(10)]
li2 = map(maps,li)
for i in li2:
print(i,end = ' ')
--------------
0 10 20 30 40 50 60 70 80 90 100
reduce函数(functools包)
将一个迭代对象归并
程序写的有点不明，个人理解是迭代序列的结果再次迭代，如下：
reduce({1, 2, 3, 4, 5}) ==
f(f(f(f(1, 2),3),4),5)
from functools import reduce
#定义一个操作数函数
def add(x, y):
return x+ y
rde = reduce(add, [1,2,3,4,5,])
print(rde)
-------
15
filter函数（与map做比较）
对数据序列进行过滤，符合条件的会生成一个新的列表
与map相比较：
- 相同： 都对元素系列进行过滤，都对序列中的每一个元素进行操作
- 不同：
- map会生成跟原来数据相对应的新序列队列
- 而filter会将符合条件的元素送进新的数据集合
def iseven(n):
return a%2 == 0
lst = [3,4,56,3,2,3,4556,67,4,4,3,23455,43]
rst = filder(iseven, lst)
print(rst)
print([i for i in rst])
--------------
<filder oject 0×7f503403df60>
[4,56,2,4556,4,4]
高阶函数的排序（key，reverse）
就是对某些函数参数进行了学习
- 正常情况下的排序
a = [-43, 23, 45, 6, -23, 2, -4345]
al = sorted.(a, reverse = True)
print(al)
----
[45, 23, 6, 2, -23, -43, -4345]
- 高阶一点的排序
# 案例一 按照绝对值进行排序
a = [-43, 23, 45, 6, -23, 2, -4345]
al = sorted.(a, key = abs, reverse = True)
print(al)
---------
[-4345, 45, -43, 23, -23, 6, 2]
---------
# 案例二 将字符列表转换为小写后再进行排序
str = ['da', 'Da', 'Xi']
str1 = sorted(str, key = str.lower)
print(str1)
------------------------
['da', 'Da', 'Xi']
--------------------------
返回函数（return fun）
嵌套函数定义，返回一个函数
网上教程中的函数变量类型为 函数
我这里是int…
#案例一
def fun(*lit ):
def sum():
s = 0
for i in lit:
s += i
return s
return sum()
# list1 = [i for i in range(10)]
# print(list1)
s1 = fun(1, 2, 3, 4, 5, 6, 7, 8, 9)
print(type(s1))
print(s1)
--------------------------
<class 'int'>
45
safaf
--------------------------
#案例二
def fun1():
def fun2():
print("yayaya")
return 3
return fun2()
f1 = fun1()
print(f1)
-----------------------
yayaya
3
闭包（closure）
‘ 参考：
在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。
满足三个条件：
- 外函数内定义有内函数
- 内函数中使用的外函数的临时变量
- 外函数返回的是内函数的引用
‘经常使用闭包实现面向对象编程’
下面展示一个小例子：
#闭包函数的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer( a ):
b = 10
# inner是内函数
def inner():
#在内函数中 用到了外函数的临时变量
print(a+b)
# 外函数的返回值是内函数的引用
return inner
if __name__ == '__main__':
demo = outer(5)
demo() # 15
demo2 = outer(7)
demo2()#17
-----------------
5
7
------------------
装饰器（decrator：返回布尔值）
在不动函数代码的基础上扩展函数功能，有时候原函数不能再进行修改，但是想要添加功能，可以用装饰器
装饰器就像帽子一样，定义扩展函数时使用装饰器，装饰器会跟这个函数绑定在一起，每次在执行这个函数时，会将这个函数作为参数传入帽子中。
‘ 参考：
使用方法：
- 先定义一个装饰函数（帽子）（也可以用类、偏函数实现）
- 再定义你的业务函数、或者类（人）
- 最后把这顶帽子带在这个人头上
参考下面程序
# 这是装饰函数，也就是帽子
def logger(func):
def wrapper(*args, **kw):
print('我准备开始计算：{} 函数了:'.format(func.__name__))
# 真正执行的是这行。
func(*args, **kw) #就这句是关键，记得参数对应
print('啊哈，我计算完啦。给自己加个鸡腿！！')
return wrapper
#在定义一个扩展函数
@logger
def add(x, y):
print('{} + {} = {}'.format(x, y, x+y))
#然后计算一下
add(200, 50)
-----------
我准备开始计算：add 函数了:
200 + 50 = 250
啊哈，我计算完啦。给自己加个鸡腿！
-----------
偏函数（使用functools模块）
在调用函数时，有时你想要固定其中的一两个函数，但如果没有偏函数来固定其中的函数参数，你每一次调用都要输出函数要求的所有参数，使用偏函数可以将函数一些功能固定，省去一些麻烦
作用：将一个函数功能固定，返回一个新的函数
例子：将mod函数的第一个参数固定
from functools import partial
def mod( n, m ):
return n % m
mod1 = partial( mod, 100 ) #前面是函数，后面的参数是将mod函数第一个参数
print mod( 100, 7 )
print mod1( 7 )
------------
2
2
------------
[scode type=“share”]
4488
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
