Python的四大高阶函数

1.map():

• 格式：map(function（函数）,Iterable（操作对象))
• 作用：将可迭代对象的每一个元素传入函数中进行同样的操作，将结果返回一个迭代器中
• 参数： 

1. function--函数，有两个参数
2. iterable--一个或者多个可迭代的对象（如序列      

# 1.参数说明：
    function:一个函数
    Iterable:可迭代对象
# 2.函数的作用：
    1>.将可迭代对象的每一个元素作为参数传入指定的函数
    2>.对元素进行操作，最终返回一个迭代器。
# 3.将列表中的每一个元素+10后生长一个新的列表
def func(p):
    return p + 10
lst = [1,3,5,9,18]
set = map(func,lst)
print(list(ret))  # [11,13,15,19,28]

# 注：
    1.代码运行的轨迹：将列表中元素一次取出，作为参数传进func函数中进行操作，将结果放入一个迭代器
    2.set(map函数的返回值)是一个爹迭代器
    3.迭代器必须实现__iter__和__next__魔法方法
    4.迭代器本身也是可迭代的(即迭代器本身就是一个可迭代的对象)

2.reduce():

• 格式:reduce(function,Iterable)
• 作用：将可迭代对象的元素进行累积操作
• 参数
  • function--函数，有两个参数
  • iterable--可迭代对象
• 返回值：返回函数计算结果

# 导包
from functools import reduce
lst = [1,2,3,4]
def func(a,b):
    return a*b
ret = reduce(func,lst)
print(ret)               # 24

# ret 是一个变量
# reduce（函数，可迭代对象）


# 代码的运行轨迹
1、将列表的前两个元素作为参数传入func函数中
2、将前两个元素运行的结果作为第一个参数，列表的第三个元素作为第二个参数再次传入
3、将前两次运行的结果与列表下一个元素作为参数再次传入，直至元素全部调用

3.filter()

• 格式：filter(function,Iterable)
• 作用：根据function内规则筛选可迭代对象中的元素，如果function返回True,这个元素保留，否则，抛弃掉
• 参数：
  • function--判断函数
  • iterable--可迭代对象（比如序列）
• 返回值：返回一个迭代器对象（即直接打印时输出对象的位置）

lst = [5,12,36,41,78]
def func(params):
    # 如果满足条件，返回true    
    if param % 3 == 0:
        return Ture
ret = filter(func,lst)
print(lst(ret))            # [12,36,78]

# 函数的运行轨迹：将可迭代对象的每一个元素传入函数中进行判断，元素满足条件时返回True,最后将返回Ture的其中另一个迭代器

4.sorted():

• 格式：sorted(Iterable,key=function,reverse=False)
• 作用：将可迭代对象的元素传入key指定的函数中，然后根据function的返回值进行排序，升降序由reverse而定
• 参数：
  • iterable--可迭代对象
  • key--指定的函数作用于可迭代对象上的每一个元素，并根据key函数返回的结果进行排序
  • reverse--排序规则，reverse = True降序，reverse  = False升序（默认）
• 返回值：返回重新排序的列表

lst = [1,9,3,5,4,2]
# lst 这个列表是内置的一个类的实例
# lst 对象的sort方法，没有返回值，所以打印ret为None
# lst.sort()方法会直接对原数据修改
ret  = lst.sort()
print(lst.sort())     等同于  print(ret)
print(lst)            # [1,2,3,4,5,9]

lst = [1,9,3,5,4,2]
# lst这个列表是内置的一个类的实例
# lst对象的sort方法, 没有返回值, 所以打印ret为None
# lst.sort()方法会直接对原数据修改
ret = lst.sort()
print(lst.sort())	等同于 print(ret)   # None
print(lst)          # [1, 2, 3, 4, 5, 9]

lst = [1, 9, 3, 5, 4, 2]
ret = sorted(lst)
ret1 = sorted(lst, reverse=True)
# sorted()是一个函数，他的排序会将原有的列表复制出来一份，然后进行排序
# sorted()不会改变原函数
print(lst)			# [1, 9, 3, 5, 4, 2]（原函数未修改）
print(ret)			# [1, 2, 3, 4, 5, 9]
print(ret1)			# [9, 5, 4, 3, 2, 1] （reverse=True ，代表降序，= Flase或不写时代表升序）

lst = [11, 19, 13, 15, 42, 28]
def func(param):
    return param % 10
ret = sorted(lst, key=func)
print(ret)		#[11, 42, 13, 15, 28, 19]
# key=abs  绝对值函数
ret_02 = sorted([-99, 66, 77, 88, 4, 5, 6, -21, -22, 33], key=abs)
print(ret_02)	#[4, 5, 6, -21, -22, 33, 66, 77, 88, -99]（结果根据绝对值排序）