Python中filter函数map函数reduce函数的区别

1.匿名函数

释义：

• 用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤，是对函数的简写。

参数说明：

• lambda函数的语法只包含一个语句，如下：
• argument： 参数，命令行参数

lambda [arg1 [,arg2,.....argn]]:expression

注意：

• Lambda函数能接收任何数量的参数但只能返回一个表达式的值
• 匿名函数不能直接调用print，因为lambda需要一个表达式

示例如下：

#无参数无返回值的函数
def my_print():
    print("你好，Python")
my_print()

#当前表达式的定义
f=lambda :print("你好，Python")
f()#函数的调用
#等价于  以下函数的定义加调用
(lambda :print("你好，Python"))()

#无参数有返回值的函数
def my_pi():
    return 3.14
print(my_pi())
·
f=lambda:3.14
print(f())

#有参数无返回值函数
def my_print(name):
    print('你好,%s'%name)
my_print("xiaohong")

f=lambda name:print('你好,%s'%name)
f('小红')

#有参数有返回值的函数
def add2num(a,b):
    return a+b
print(add2num(2,3))

f=lambda a,b:a+b
print(f(1,2))

2.filter函数

1.定义：
filter()函数用于对序列过滤，过滤掉不符合条件的元素，返回一个迭代器对象，其中包含对其执行函数时结果为真的所有元素，过滤掉不符合条件的元素
2.语法：
filter(func,seq)该函数接收两个参数，第一个为函数，第二个为可迭代对象

def use_filter(data):
    # 使用result接收filter过滤偶数值的功能
    result = filter(lambda x: x % 2 == 0, data)
    return result

if __name__ == '__main__':
    # 使用data接收0-50的数值t
    # data = [i for i in range(51)]
    data = range(51)
    # 调用use_filter函数传入data，使用resul变量接收
    result = use_filter(data)
    print(list(result))
# range()函数可创建一个整数列表，
# range(start, stop[, step])
# start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
# stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
# step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

3.map函数

1.定义：
创建一个列表，其中包含对指定序列包含的项执行指定函数返回的值，是根据提供的函数对指定序列做映射。即是将传入的函数依次作用到序列的每个元素，并把结果返回。即返回结果是一个map对象
2.语法：
map(function，sequence，…)，该接收两个参数，一个是函数，一个是序列；

rest = map(lambda x, y: x*y, [3, 5], [3, 5])
print(list(rest))   # [9, 25]
//当map()函数种传入的列表多于一个时，map()函数可以并行执行

求列表中元素的立方方法

# 求列表中元素的立方方法
def pow_number(L):
    """
    使用for循环
    :param L: list/type int类型的列表或者是元组
    :return:原来列表中每一项的立方
    """
    rest_list = []
    for x in L:
        rest_list.append(x*x*x)
    return rest_list

def f(n):
    return n*n*n


def pow_number_use_map(L):
    """
     使用map函数
    :param L: list/type int类型的列表或者是元组
    :return:原来列表中每一项的立方
    """
    return map(f, L)

def pow_number_use_lambda(L):
    """
     使用lambda函数
    :param L: list/type int类型的列表或者是元组
    :return:原来列表中每一项的立方
    """
    res = map(lambda n: n*n*n, L)

    return res



if __name__ == '__main__':
    X = range(1, 10)
    rest = pow_number(X)
    print(rest)
    print("*"*40)
    rest = pow_number_use_map(X)
    print (list(rest))
    print("*" * 40)
    rest = pow_number_use_map(X)
    print(list(rest))
    print("*" * 40)
    rest = pow_number_use_lambda(X)
    print(list(rest))

4.reduce函数

1.定义：
使用指定的函数将序列的前两个元素合二为一，再将结果与第3个元素合二为一，以此类推，直到处理完整个序列并得到一个结果值
2.语法：
reduce（func,seq[.initial]） 等价于func(func(func(seq[0],seq[1],)seq[2],…))
两个参数分别是函数和列表名

# 计算1-20的乘积
from functools import reduce

def use_reduce(data):

    result = reduce(lambda x, y: x*y, data)
    return result
if __name__ == '__main__':
    data = range(1, 21)
    res = use_reduce(data)
    print(res)

序列求和的4种方法

from functools import  reduce
# 求序列和
def get_sum(data):
    """
    根据给定的列表，求里面的各个数字的总和
    :param data:  list/type 里面是整数
    :return:列表所有项的和
    """
    rest = 0
    for i in data:
        rest += i
    return rest
def get_sum2(data):
    """
    内置函数
    :param data:  list/type 里面是整数
    :return:列表所有项的和
    """
    return sum(data)

def f(m,n):
    return m+n


def get_sum_reduce(data):
    """
       reduce+普通函数
       :param data:  list/type 里面是整数
       :return:列表所有项的和
       """
    return reduce(f, data)

def get_sum_lambda(data):
    """
       reduce函数+匿名函数
       :param data:  list/type 里面是整数
       :return:列表所有项的和
       """
    return reduce(lambda m, n: m+n, data)

if __name__ == '__main__':
    data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    result = get_sum(data)
    print(result)
    print("——————————————————————————————")
    result_1 = get_sum2(data)
    print(result_1)
    print("——————————————————————————————")
    result_2 = get_sum_reduce(data)
    print(result_2)
    print("——————————————————————————————")
    result_3 = get_sum_lambda(data)
    print(result_3)