Python reduce / map / filter 函数区别 - Python零基础入门教程

川长思鸟来 2022-10-08 11:12 111阅读 0赞

*  一.map 函数
 *  二.reduce 函数
 *  三.filter 函数
 *  四.猜你喜欢

> 零基础 Python 学习路线推荐 : [Python 学习目录][Python] >> [Python 基础入门][Python 1]

[Python][Python 2] 中 **[reduce][] / [map][] / [filter][]** 三个函数很容易搞混淆，虽然利用函数对迭代器或者序列中的元素操作，但是适用的场景却各不相同；

## 一.map 函数 ##

**[map 函数][map]特点：对可迭代器或者序列中的每个元素进行相同的操作（例如每个元素+1 等等），并返回迭代器或者列表**，示例如下：

# !usr/bin/env python
    # -*- coding:utf-8 _*-
    """
    @Author:猿说编程
    @Blog(个人博客地址): www.codersrc.com
    @File:Python reduce / map / filter 函数区别.py
    @Time:2021/05/18 07:37
    @Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
    
    """
    
    def func1(x):
        # 将每一个元素计算平方值
        print("x=%d x*x=%d"%(x,x*x))
        return x*x
    
    if __name__ == "__main__":
        list1 = [1,2,3,4,5]
        #方法一：
        value = map(func1,list1) #返回map对象，可以强制转为list列表
        print(list(value))
    
        print("***"*20)
        #方法二：
        value = map(lambda x:x*x, list1)  #返回map对象，可以强制转为list列表
        print(list(value))
    
    
    '''
    输出结果：
    
    x=1 x*x=1
    x=2 x*x=4
    x=3 x*x=9
    x=4 x*x=16
    x=5 x*x=25
    [1, 4, 9, 16, 25]
    ************************************************************
    [1, 4, 9, 16, 25]
    '''

值得注意的是：**map 函数返回值是迭代器，注意返回的结果只能迭代一次，如果需要多次使用请提前保存结果并处理，例如：**

def func1(x):
        # 将每一个元素计算平方值
        # print("x=%d x*x=%d"%(x,x*x))
        return x*x
    
    if __name__ == "__main__":
        list1 = [1,2,3,4,5]
        value = map(func1,list1) #返回map对象，可以强制转为list列表
        print(list(value))
        print(list(value))
    
    '''
    输出：
    
    [1, 4, 9, 16, 25]
    []
    '''

很懵逼是不是？明明没什么错误，为什么第二次输出就是空列表呢？因为 map 函数返回的迭代器只能迭代一次，解决办法：**在获取结果的时候强转为[ list 列表 ][list _]即可**,实例如下：

# !usr/bin/env python
    # -*- coding:utf-8 _*-
    """
    @Author:猿说编程
    @Blog(个人博客地址): www.codersrc.com
    @File:Python reduce / map / filter 函数区别.py
    @Time:2021/05/18 07:37
    @Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
    
    """
    
    def func1(x):
        # 将每一个元素计算平方值
        # print("x=%d x*x=%d"%(x,x*x))
        return x*x
    
    if __name__ == "__main__":
        list1 = [1,2,3,4,5]
        value = list(map(func1,list1)) #返回map对象，可以强制转为list列表
        print(list(value))
        print(list(value))
    
    '''
    输出：
    
    [1, 4, 9, 16, 25]
    [1, 4, 9, 16, 25]
    '''

## 二.reduce 函数 ##

**[reduce 函数][reduce]特点：从左到右对一个序列的项累计地应用有两个参数的函数，以此合并序列到一个单一值（例如累加或累乘列表元素等等），返回最终的计算结果，是一个值**，示例如下：

# !usr/bin/env python
    # -*- coding:utf-8 _*-
    """
    @Author:猿说编程
    @Blog(个人博客地址): www.codersrc.com
    @File:Python reduce / map / filter 函数区别.py
    @Time:2021/05/18 07:37
    @Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
    
    """
    
    #python3在使用reduce函数时需要导入模块
    
    from functools import reduce # 导入模块
    
    def func1(x,y):
        # 把上一次计算的结果作为下一次的计算的输入
        print("x=%d y=%d x*y=%d"%(x,y,x*y))
        return x*y
    
    if __name__ == "__main__":
        list1 = [1,2,3,4,5]
        #方法一：
        value = reduce(func1,list1) #等价 1*2*3*4*5 = 120
        print(value)
        print(type(value))
    
        print("***"*20)
        #方法二：
        value = reduce(lambda x,y:x*y, list1)  # 等价 1*2*3*4*5 = 120
        print(value)
        print(type(value))
    
    '''
    输出结果：
    
    x=1 y=2 x*y=2
    x=2 y=3 x*y=6
    x=6 y=4 x*y=24
    x=24 y=5 x*y=120
    120
    <class 'int'>
    ************************************************************
    120
    <class 'int'>
    '''

## 三.filter 函数 ##

\*\*[filter 函数][filter]\*\*特点：对可迭代对象中的元素按照特定的条件进行筛选（例如筛选列表中所有的偶数等等），示例如下：

# !usr/bin/env python
    # -*- coding:utf-8 _*-
    """
    @Author:猿说编程
    @Blog(个人博客地址): www.codersrc.com
    @File:Python reduce / map / filter 函数区别.py
    @Time:2021/05/18 07:37
    @Motto:不积跬步无以至千里，不积小流无以成江海，程序人生的精彩需要坚持不懈地积累！
    
    """
    
    
    lis=[0,1,2,3,4,5,6]
    
    #定义筛选偶数的普通函数
    def func4(x):
        return x%2==0
    
    #第一种使用filter函数的方式---lambda
    res5=filter(lambda x:x%2==0,lis)
    print(list(res5))
    print(list(res5))
    print("***"*20)
    
    
    #第二种使用filter函数的方式---普通函数二
    res7=filter(func4,lis)
    print(list(res7))
    print(list(res7))
    
    '''
    输出结果：
    
    [0, 2, 4, 6]
    []
    ************************************************************
    [0, 2, 4, 6]
    []
    '''

懵逼？事实证明，filter 函数返回的结果也和 map 函数一样，只能迭代一次，解决方案和 map 的解决方案一样，在获取结果的时候强转为[\*\* list 列表\*\* ][list _ 1]即可；

## 四.**猜你喜欢** ##

1.  [Python 条件推导式][Python 3]
2.  [Python 列表推导式][Python 4]
3.  [Python 字典推导式][Python 5]
4.  [Python 不定长参数 \*argc/\*\*kargcs][Python _ _argc_kargcs]
5.  [Python 匿名函数 lambda][Python _ lambda]
6.  [Python return 逻辑判断表达式][Python return]
7.  [Python is 和 == 区别][Python is _ _]
8.  [Python 可变数据类型和不可变数据类型][Python 6]
9.  [Python 浅拷贝和深拷贝][Python 7]
10. [Python 异常处理][Python 8]
11. [Python 线程创建和传参][Python 9]
12. [Python 线程互斥锁 Lock][Python _ Lock]
13. [Python 线程时间 Event][Python _ Event]
14. [Python 线程条件变量 Condition][Python _ Condition]
15. [Python 线程定时器 Timer][Python _ Timer]
16. [Python 线程信号量 Semaphore][Python _ Semaphore]
17. [Python 线程障碍对象 Barrier][Python _ Barrier]
18. [Python 线程队列 Queue – FIFO][Python _ Queue _ FIFO]
19. [Python 线程队列 LifoQueue – LIFO][Python _ LifoQueue _ LIFO]
20. [Python 线程优先队列 PriorityQueue][Python _ PriorityQueue]
21. [Python 线程池 ThreadPoolExecutor(一)][Python _ ThreadPoolExecutor]
22. [Python 线程池 ThreadPoolExecutor(二)][Python _ ThreadPoolExecutor 1]
23. [Python 进程 Process 模块][Python _ Process]
24. [Python 进程 Process 与线程 threading 区别][Python _ Process _ threading]
25. [Python 进程间通信 Queue / Pipe][Python _ Queue _ Pipe]
26. [Python 进程池 multiprocessing.Pool][Python _ multiprocessing.Pool]
27. [Python GIL 锁][Python GIL]

未经允许不得转载：[猿说编程][Link 1] » [Python reduce / map / filter 函数区别][Python reduce _ map _ filter]

[Python]: https://www.codersrc.com/python
[Python 1]: https://www.codersrc.com/pythonsimple
[Python 2]: https://www.codersrc.com/
[reduce]: https://www.codersrc.com/archives/7011.html
[map]: https://www.codersrc.com/archives/5765.html
[filter]: https://www.codersrc.com/archives/6200.html
[list _]: http://www.shuopython.com/archives/1096
[list _ 1]: https://www.codersrc.com/archives/5061.html
[Python 3]: https://www.codersrc.com/archives/5346.html
[Python 4]: https://www.codersrc.com/archives/5359.html
[Python 5]: https://www.codersrc.com/archives/5377.html
[Python _ _argc_kargcs]: https://www.codersrc.com/archives/5443.html
[Python _ lambda]: https://www.codersrc.com/archives/5756.html
[Python return]: https://www.codersrc.com/archives/5759.html
[Python is _ _]: https://www.codersrc.com/archives/5288.html
[Python 6]: https://www.codersrc.com/archives/5271.html
[Python 7]: https://www.codersrc.com/archives/5492.html
[Python 8]: https://www.codersrc.com/archives/5966.html
[Python 9]: https://www.codersrc.com/archives/6015.html
[Python _ Lock]: https://www.codersrc.com/archives/6048.html
[Python _ Event]: https://www.codersrc.com/archives/6486.html
[Python _ Condition]: https://www.codersrc.com/archives/6508.html
[Python _ Timer]: https://www.codersrc.com/archives/6538.html
[Python _ Semaphore]: https://www.codersrc.com/archives/6563.html
[Python _ Barrier]: https://www.codersrc.com/archives/6581.html
[Python _ Queue _ FIFO]: https://www.codersrc.com/archives/6609.html
[Python _ LifoQueue _ LIFO]: https://www.codersrc.com/archives/6651.html
[Python _ PriorityQueue]: https://www.codersrc.com/archives/6674.html
[Python _ ThreadPoolExecutor]: https://www.codersrc.com/archives/6707.html
[Python _ ThreadPoolExecutor 1]: https://www.codersrc.com/archives/6732.html
[Python _ Process]: https://www.codersrc.com/archives/6765.html
[Python _ Process _ threading]: https://www.codersrc.com/archives/6788.html
[Python _ Queue _ Pipe]: https://www.codersrc.com/archives/6826.html
[Python _ multiprocessing.Pool]: https://www.codersrc.com/archives/6857.html
[Python GIL]: https://www.codersrc.com/archives/6860.html
[Link 1]: https://www.codersrc.com
[Python reduce _ map _ filter]: https://www.codersrc.com/archives/7026.html