Python 函数进阶-高阶函数

高阶函数

什么是高阶函数

高阶函数就是能够把函数当成参数传递的函数就是高阶函数，换句话说如果一个函数的参数是函数，那么这个函数就是一个高阶函数。

高阶函数可以是你使用def关键字自定义的函数，也有Python系统自带的内置高阶函数。

自定义一个高阶函数

我们下面的例子中，函数 senior 的参数中有一个是函数，那么senior就是一个高阶函数；函数 tenfold 的参数不是函数，所以tenfold就只是一个普通的函数。

# 定义高阶函数
def senior(func, container):
   """
   将容器中的数据依次放入函数中进行运算，
   将结果返回到迭代器中，最后返回迭代器。
   """
   lst = list()
   for i in container:
      lst.append(func(i))
   return iter(lst)


# 定义普通的功能函数
def tenfold(num):
   """
   十倍器
   将数据乘 10，返回结果。
   """
   return num * 10


# 定义一个列表
lst = [10, 20666, 'msr']

# 使用高阶函数
it = senior(tenfold, lst)
print(list(it)) # [100, 206660, 'msrmsrmsrmsrmsrmsrmsrmsrmsrmsr']

常用的内置高阶函数

函数	功能作用
map	处理可迭代对象中的数据，将处理的结果返回到迭代器中。
filter	过滤可迭代对象中的数据，将过滤好的数据返回到迭代器中。
reduce	处理可迭代对象中的数据，将最终的结果返回出来。
sorted	排序可迭代对象中的数据，将排序好的结果返回出来。

map函数

语法：map(function, Iterable)

参数说明

function：函数，可以是 自定义函数 或者是 内置函数；

iterable：可迭代对象，可迭代性数据。（容器类型数据和类容器类型数据、range对象、迭代器）

功能

把可迭代对象中的数据一个一个拿出来，然后放在到指定的函数中做处理，将处理之后的结果依次放入迭代器中，最后返回这个迭代器。

实例

将列表中的元素转成整型类型，然后返回出来。

lst = ['1', '2', '3', '4']

""" 使用常规的写法 """
new_lst = list()
for i in lst:
    new_lst.append(int(i))
print(new_lst)  # [1, 2, 3, 4]


""" 使用map函数实现 """
it = map(int, lst)
new_lst = list(it)
print(new_lst)  # [1, 2, 3, 4]

列表中的每一个数依次乘 2的下标索引+1 次方。使用自定义的函数，配合实现功能。

lst = [1, 2, 3, 4]

""" 普通的方法，利用左移 """
new_lst = list()
for i in lst:
	res = i << i
	new_lst.append(res)
print(new_lst)  # [2, 8, 24, 64]


""" 使用map函数 """
# 先定义一个左移函数，自定义的函数必须是一个带参函数并且有返回值
def func(num):
	return num << num
new_lst = list(map(func, lst))
print(new_lst)  # [2, 8, 24, 64]


""" 使用lambda简化 """
new_lst = list(map(lambda num: num << num, lst))
print(new_lst)  # [2, 8, 24, 64]

filter函数

语法：filter(function, iterable)

参数的意义和map函数一样

功能

filter用于过滤数据，将可迭代对象中的数据一个一个的放入函数中进行处理，如果函数返回值为真，将数据保留；反之不保留，最好返回迭代器。

实例

保留容器中的偶数

lst = [11, 2, 3, 34, 4, 4, 55]

""" 常规写法 """
new_lst = list()
for i in lst:
   if i % 2 == 0:
      new_lst.append(i)
print(new_lst)  # [2, 34, 4, 4]


""" 使用filter函数 """
def func(num):
   if num % 2 == 0:
      return True
new_lst = list(filter(func, lst))
print(new_lst)  # [2, 34, 4, 4]


""" filter + lambda """
new_lst = list(filter(lambda num: True if (num % 2 == 0) else False, lst))
print(new_lst)  # [2, 34, 4, 4]

reduce函数

语法：reduce(function, iterable)

参数含义与map、filter一致。

功能

计算数据，将可迭代对象的中的前两个值放在函数中做出运算，得出结果在和第三个值放在函数中运算得出结果，以此类推，直到所有的结果运算完毕，返回最终的结果。

根据功能我们就应该直到，reduce中的函数需要可以接收两个参数才可以。

实例

reduce函数使用需要先从标准库functools中导入

将列表中的数据元素组合成为一个数，

from functools import reduce

lst = [2, 0, 6, 6, 6]


""" 常规方法 """
char = str()
for i in lst:
   char += str(i)
print(int(char))    # 20666


""" 使用reduse函数 """
def func(x, y):
   return x * 10 + y
res = reduce(func, lst)
print(res)  # 20666


""" reduce + lambda """
res = reduce((lambda x, y: (x * 10 + y)), lst)
print(res)  # 20666

sorted函数

语法：sorted(Iterable, key=function, reverse=False)

参数说明

iterable：可迭代对象；

key：指定函数，默认为空；

reverse：排序的方法，默认为False，意为升序；

功能

如果没有指定函数，就单纯的将数据安札ASCII进行排序；如果指定了函数，就将数据放入函数中进行运算，根据数据的结果进行排序，返回新的数据，不会改变原有的数据。

注意，如果指定了函数，排序之后是根据数据的结果对原数据进行排序，而不是排序计算之后的就结果数据。

实例

将列表中的数据进行排序。

lst = [1, 23, 34, 5, 6, 342, 12, 12, 2345, -3]

""" 使用列表的内置函数进行排序，默认升序 """
lst.sort()
print(lst)  # [-3, 1, 5, 6, 12, 12, 23, 34, 342, 2345]
# 降序排序
lst.sort(reverse=True)
print(lst)  # [2345, 342, 34, 23, 12, 12, 6, 5, 1, -3]


lst = [1, 23, 34, 5, 6, 342, 12, 12, 2345, -3]
""" 使用sorted进行排序 """
new_lst = sorted(lst)
print(new_lst)  # [-3, 1, 5, 6, 12, 12, 23, 34, 342, 2345]
print(lst)      # [1, 23, 34, 5, 6, 342, 12, 12, 2345, -3]

还有一点就是 sorted 函数可以将数据放入函数中进行处理，然后根据结果进行排序。

lst = [1, 23, 34, 5, 6, 342, 12, 12, 2345, -3]

""" 按照绝对值进行排序 """
new_lst = sorted(lst, key=abs)
print(new_lst)  # [1, -3, 5, 6, 12, 12, 23, 34, 342, 2345]


""" 按照除以10的余数进行排序 """
def func(num):
   return num % 10
new_lst = sorted(lst, key=func)
print(new_lst)  # [1, 342, 12, 12, 23, 34, 5, 2345, 6, -3]

# 可以看到，我们指定函数之后排序的结果既不是原数据的绝对值、也不是原数据除以10的余数，而是根据这两种计算结果对原数据进行了排序。

sort和sorted

既然有了列表的内置函数sort，为什么我们还要使用sorted函数呢？

1. sorted可以排序一切可迭代对象，但是sort只是列表的内置函数，只能对列表进行排序；
2. sorted排序返回新的数据，不改变原数据，sort改变了原数据；
3. sorted可以指定函数，根据函数的计算结果、按照某一种方式进行排序，但是sort只能单纯的根据数字大小和ASCII进行排序。

总结

高阶函数就是将函数作为参数的函数。

map(Function,Iterable)（将可迭代性数据中的元素一一取出放入函数中进行运算在将结果返回，最后返回的数据类型是迭代器）

filter(Function,Iterable)（过滤数据，将可迭代性数据放入函数中进行运算，结果为真将数据返回，反之舍弃，最会返回的数据类型是迭代器）

reduce(Function,Iterable)（计算数据，将可迭代型数据中的前两个元素拿出放入函数中进行运算将结果在与后一个元素进行运算，最后返回最终的结果）

sorted(Iterable,[key=Function],[reverse =Bool(False(default)/True)])（将可迭代型数据进行排序，或将可迭代型数据放入函数中进行运算将结果进行排序返回）