python的高阶函数-map()/reduce()/filter()/sorted()

高阶函数：就是把函数当成参数传递的一种函数。例如以下函数即为一个高阶函数。

1.高阶函数示例

"""
abs绝对值
"""


def add(x, y, f):
    return f(x) + f(y)


print(add(-8, -22, abs))

注解：

1.调用add函数，分别执行abs(-8)和abs(11),分别计算出他们的值

2.最后再做和运算

2.map()函数

python内置的一个高阶函数，它接收一个函数function和一个iterable序列,并且把序列的元素依此传递给函数function，Python 3.x 返回一个函数function处理完所有序列元素的迭代器，如下：

"""
map()函数
"""


def func1(x):
    return x ** 2


li = [1, 2, 3, 4, 5]
print(map(func1, li))   # 返回一个迭代器对象<map object at 地址>

print("map()函数的使用：")
for i in map(func1, li):
    print(i, end=' ')
print('\n')
print("*"*50)

print("使用lambda匿名函数：")
for i in map(lambda x: x**2, [1, 2, 3, 4, 5]):    # 使用lambda匿名函数
    print(i, end=' ')
print('\n')
print("*"*50)

print("多个序列的操作：")
for i in map(lambda x, y: x*y, [1, 2, 3, 4, 5], [6, 7, 8, 9, 10]):   # 提供了两个列表，对相同位置的列表数据进行相加
    print(i, end=' ')
print('\n')   

运行结果：

<map object at 0x0000000002367A20>
map()函数的使用：
1 4 9 16 25 

**************************************************
使用lambda匿名函数：
1 4 9 16 25 

**************************************************
多个序列的操作：
6 14 24 36 50 

3.reduce()函数

reduce()函数也是python的内置高阶函数，reduce()函数接收的的参数和map()类似，一个函数f，一个可迭代对象，但行为和map()不同，reduce()传入的参数f必须接受2个参数，

第一次调用是把可迭代对象的前两个元素传递给f,第二次调用时，就是把前两个可迭代对象元素的计算结果当成第一个参数，可迭代对象的第三个元素当成第二个参数，传入f进行操作，以此类推，并最终返回结果；

python3.x需要从functools导入这个函数。

"""
reduce()函数
"""


from functools import reduce


def func2(x, y):
    return x+y


print(reduce(func2, [1, 2, 3, 4, 5], 10))
print(reduce(func2, [1, 2, 3, 4, 5]))

注解：（1）print(reduce(func2, [1, 2, 3, 4, 5], 10))

1，计算a=func2(1,2)的值为3

2，计算b=func2(a,3)的值为6

3，计算c=func2(b,4)的值为10

4，计算d=func2(c,5)的值为15

5，计算func2(d,10)的值为25

其实就是相当于1+2+3+4+5+10 ,最后的10为默认值，及最终执行一次

注解：（2） print(reduce(func2, [1, 2, 3, 4, 5]))

   1，计算a=func2(1,2)的值为3
    
    2，计算b=func2(a,3)的值为6
    
    3，计算c=func2(b,4)的值为10
    
    4，计算d=func2(c,5)的值为15
    

运行结果：

4.filter()函数

filter()函数是python内置的另一个有用的高阶函数，filter()函数接收一个函数f和一个可迭代对象,这个函数f的作用是对每个元素进行判断，返回true或false,filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件的元素组成的可迭代对象;

"""
filter()函数
"""


def func3(x):
    return x % 2 == 0


print("filter()函数：")
# for i in filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5]):   # 使用lambda匿名函数
for i in filter(func3, [1, 2, 3, 4, 5]):
    print(i, end=' ')

print('\n')

注解：

注解：

1.可迭代对象元素依此传入到函数func3

2.func3判断每个元素是否符合条件，把符合条件的留下，不符合条件的舍弃

3.把最终符合条件的元素组成一个新的可迭代对象，可以遍历取值

运行结果：

5.sorted()函数

sorted() 函数对所有可迭代的对象进行排序操作。

5.1 sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

5.2 sorted 语法：

sorted(iterable[, key[, reverse]])

参数说明：

• iterable – 可迭代对象。
• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

"""
sorted()函数
"""
li = [2, 5, 7, 1, 4, 9, -1]
dict2 = [{'name': 'zs', 'age': 15}, {'name': 'ls', 'age': 5}, {'name': 'ww', 'age': 12}]

print("sorted排序后生成一个新列表：", sorted(li))
print("sorted排序后原列表不改变：", li)

print(sorted(dict2, key=lambda x: x['age'], reverse=True))    # 按age降序排序
print(sorted(dict2, key=lambda x: x['name']))   # 按name升序排序

运行结果：

6.扩展一个python的内置函数——zip()函数

1. zip()参数可以接受任何类型的序列，同时也可以有两个以上的参数;当传入参数的长度不同时，zip能自动以最短序列长度为准进行截取，获得元组。
2. 在python 3.0中zip()是可迭代对象，使用时必须将其包含在一个list中，方便一次性显示出所有结果
3. 搭配for循环，支持并行迭代操作方法

"""
zip()函数
"""
# 使用zip()函数来可以把列表合并，并创建一个元组对的列表。
# 在python 3.0中zip()是可迭代对象，使用时可以将其包含在一个list中，方便一次性显示出所有结果
print(list(zip([1, 2, 3], [4, 5, 6])))    # 合并成元组组成的列表  [(1, 4), (2, 5), (3, 6)]
print(dict(zip(['1', '2', '3'], ['4', '5', '6'])))    # 合并成字典  {'1': '4', '2': '5', '3': '6'}
print(tuple(zip([1, 2, 3], [4, 5, 6])))    # 合并成元组组成的大元组  ((1, 4), (2, 5), (3, 6))


# zip()参数可以接受任何类型的序列，同时也可以有两个以上的参数;
# 当传入参数的长度不同时，zip能自动以最短序列长度为准进行截取，获得元组。
str1 = 'abc'
str2 = 'def123'
print(list(zip(str1, str2)))


# 搭配for循环，支持并行迭代操作方法
for x, y in zip({1, 2, 3}, {4, 5, 6}):
    print(x*y)

运行结果：