---map，filter，reduce 函数---

•                      map函数                                          

•                      reduce函数                                      

•                      filter函数                                          

一 . map函数：

 

#把这个列表里每个数都2次方
array=[1,3,4,71,2]

ret=[]
for i in array:
    ret.append(i**2)
print(ret)

#如果我们有一万个列表,那么你只能把上面的逻辑定义成函数
def map_test(array):
    ret=[]
    for i in array:
        ret.append(i**2)
    return ret

print(map_test(array))

#如果我们的需求变了,不是把列表中每个元素都平方,还有加1,减一,那么上面的函数就没法满足了-----那么看下列做法
1：用匿名函数来做
def test_1(funk,line):
    res = []
    for i in line:
        ab = funk(i)
        res.append(ab)
    return res
print(test_1(lambda x:x+1,[1,2,3,4]))-----[2,3,4,5]
print(test_1(lambda x:x-1,[1,2,3,4]))------[0,1,2,3]
print(test_1(lambda x:x**2,[1,2,3,4]))----[1, 4, 9, 16]
#上面的做法是不是还是很复杂 ----接下来看map函数是怎么是实现这个需求的：
qqx = map(lambda x:x**2,[1,2,3,4])
print(list(qqx))
运行：[1,4,9,16]
简化版：print(list(map(lambda x:x**2,[1,2,3,4]))) ---[1, 4, 9, 16]

#上面就是map函数的功能,map得到的结果是可迭代对象
print(map(lambda x:x-1,range(5)))

map函数

因为 ：print(map(lambda x:x**2,[1,2,3,4]))
          运行：<map object at 0x000002B0A26F4A20>
这里的结果是一个可迭代对象 然后必须要加 list 还得接收返回值 才可以

垃圾版：qqx = map(lambda x:x**2,[1,2,3,4])
           print(list(qqx))
        
高级版：print(list(map(lambda x:x**2,[1,2,3,4])))

运行过程：[1,2,3,4]传到 lambda里面然后因为map循环可迭代对象
所以列表里面的每一个值都在 lambda里面做了2次方 最后接受了个返回值
返回的就是每个数字都做了二次方的新列表

 

map函数其实就是给一个可迭代对象循环加减乘除等（列表 元祖 集合等）

 

1.map 里面可传匿名函数也可以传有名函数

 

传匿名函数：
print(list(map(lambda x:x**2,[1,2,3,4])))

传有名函数:
def weita(x):
    return x+1
print(list(map(weita,[7,8,9,10])))

 

 

 

2.匿名函数----lambda用法 搭配用 一般不单独使用

 二：filter 函数

#电影院聚集了一群看电影bb的傻逼,让我们找出他们
movie_people=['alex','wupeiqi','yuanhao','sb_alex','sb_wupeiqi','sb_yuanhao']

def tell_sb(x):
    return x.startswith('sb')-----等于匿名函数：lambda x：x.startswith('sb')


def filter_test(func,array):
    ret=[]
    for i in array:
        if func(i):
            ret.append(i)
    return ret

print(filter_test(tell_sb,movie_people))


#用函数filter来做,    返回可迭代对象       #可传有名和匿名函数

res = list(filter(lambda x:x.startswith('sb'),['alex','wupeiqi','yuanhao','sb_alex','sb_wupeiqi','sb_yuanhao']))  #匿名函数
print(res)
运行：['sb_alex', 'sb_wupeiqi', 'sb_yuanhao']

def qqx(n):
    return n.startswith('sb')    #先定义一个有名函数
res = list(filter(qqx,['alex','wupeiqi','yuanhao','sb_alex','sb_wupeiqi','sb_yuanhao']))     #有名
print(res)             
运行：['sb_alex', 'sb_wupeiqi', 'sb_yuanhao']


总结：可以发现 filter 函数 最后返回的是带sb的一些'人’---因为它默认是True 也就是说 把列表中的每一个值都for循环了一遍 然后判断开头包含sb 如果包含返回True然后把带有sb的值添加的列表中

那么怎么把包含sb的值去掉  只留下不包含sb的值呢？看下面函数：

res = list(filter(lambda x:not x.startswith('sb'),['alex','wupeiqi','yuanhao','sb_alex','sb_wupeiqi','sb_yuanhao']))
print(res)              #加个not就可以了
运行：['alex', 'wupeiqi', 'yuanhao']

filter函数

 总结：filter 后面两个参数，一个函数一个可迭代对象，然后对这个可迭代对象依次进行遍历 （就是for循环），然后把每一个值交给前面的函数去处理，函数处理的结果是个布尔值，如果是 True----->即满足函数的条件 就保留下来 最后形成了一个新的列表  （tu，dic，set，也都可以这样操作）

reduce 函数：

from functools import reduce    #先导入模块 才能使用reduce函数
print(reduce(lambda x,y:x+y,[1,2,3]))
print(reduce(lambda x,y:x+y,[1,2,3],1))  #第三个参数看需求 可加可不加
print(reduce(lambda x,y:x*y,[1,2,3]))
print(reduce(lambda x,y:x*y,[1,2,3],2))  
运行结果：
            6
            7
            6
           12
  

 #reduce函数就是把这个数据里面的所有值 最后通过函数是相加还是相乘，相减，相除都可以，然后得出一个最终结果
##这里加的第三个参数 这个参数是和数据的第一个值相加减乘除

 小结：

map()-----处理序列中的每个元素，得到的是一个'列表'(其实是一个迭代器），该’列表‘元素的个数和位置与原来一样

 

filter()-----遍历序列中的每一个元素，判断每个元素的得到的布尔值（这个判断依据是根据前面的函数是怎样定义而来的），如果是True，则保留下来 

举个列子：

 

#把年龄大于十八的全过滤掉 
pepol = [{'name':'a','age':1000},
      {'name':'b','age':2000},
      {'name':'c','age':3000},
      {'name':'d','age':18},
]
rse = filter(lambda n:n['age']<100,pepol)
print(list(rse))
运行结果：[{'name': 'd', 'age': 18}]


####这里是想说 filter 不单单是可以处理数字 要灵活运用

 

 

 

redduce-------处理一个序列 然后把这个序列进行合并操作

举个列子：

#reduce用来计算1到100的和
from functools import reduce

print(reduce(lambda x,y:x+y,range(100),100))
print(reduce(lambda x,y:x+y,range(1,101)))


####range切片的方式 也能达到效果