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函数
语法：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函数呢？

sorted能够排序所有可迭代对象，然而sort只是列表的内置函数，只能对列表进行排序；
sorted排序返回新的数据，不扭转原数据，sort扭转了原数据；
sorted能够指定函数，依据函数的计算结果、依照某一种形式进行排序，然而sort只能单纯的依据数字大小和ASCII进行排序。
总结
高阶函数就是将函数作为参数的函数。

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

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

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

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

以上就是本次分享的全部内容，当初想要学习编程的小伙伴欢送关注搞代码，获取更多技能与教程。

喜欢 (0)赏

[搞代码]

分享 (0)