Python高阶函数使用总结

---

什么是高阶函数？

接收函数作为参数或者把函数作为结果返回的函数是高阶函数（higher-order function）

函数作为参数

def add_num(a, b, func):
   return func(a) + func(b)

res = add_num(1, -2, abs)  # 将abs函数的引用作为参数传入add_num中
print(res)

# 输出
3

函数作为返回值

def func1():
   print("func1")

def func2(func):
   print("func2")
   return func   # 将函数作为返回值

res = func2(func=func1)
print(res)

# 输出
func2
<function func1 at 0x7ff69d1f2c20> 

高阶函数是函数式编程的体现，函数式编程即是这种抽象化的编程范式。从设计上看，Python不是一门函数式语言，但其借鉴了函数式编程中一些好的想法。
本篇博客将详细介绍以下五个Python中内置的高阶函数

• map()
• filter()
• reduce()
• sorted()/sort()
• zip()

一、map()

map(func, *iterables)

map函数将传入的func功能函数作用于可迭代序列iterables中的每个元素，最终返回一个列表（Python2）或新的迭代器（Python3）。func函数可以是Python内置函数、自定义函数或者匿名函数，以下举例说明map函数的用法

1、使用Python内置函数

a = map(abs, [-1, 2, -3, 4])
print(a)
print(list(a))  # 通过list()对map的结果处理

# 输出
<map object at 0x7f91cc1cb550>  # Python3输出的是可迭代对象
[1, 2, 3, 4]

2、使用自定义函数

def func(x):
    return x ** 2

a = map(func, [-1, 2, -3, 4])
print(a)
print(list(a))

# 输出
<map object at 0x7fa9f2b84c10>
[1, 4, 9, 16]

3、使用匿名函数

a = map(lambda x, y:  x + y, [1, 2, 3], [4, 5, 6])
print(list(a))

# 输出
[5, 7, 9]

二、filter()

filter(func, iterable)

filter函数用于过滤序列，过滤掉不符合条件的那些元素，返回符合条件的元素组成的filter对象。
将func功能函数作用于iterable可迭代序列的每个元素进行真假判断，最终返回结果为True的元素组成的序列。需要注意以下几点：

• 与map不同，filter只需要传入一个可迭代对象。
• 必须使用func参数才能返回布尔类型。 如果不是，filter仅返回传递给它的可迭代对象。 另外，由于仅需要一个可迭代的函数，因此隐含的是func必须仅接受一个参数。
• filter通过func传递可迭代对象中的每个元素，并仅返回评估为true的那些元素。

示例代码如下：

a = filter(lambda x: x % 2 == 0, list(range(10)))  # 过滤出偶数序列

dromes = ("demigod", "rewire", "madam", "freer", "anutforajaroftuna", "kiosk")
b = filter(lambda word: word == word[::-1], dromes)  # 回文串检测器

print(list(a))
print(list(b))

# 输出
[0, 2, 4, 6, 8]
['madam', 'anutforajaroftuna']

三、reduce()

from functools import reduce
reduce(function, sequence, initial=None)

Python3中将reduce函数移入functools模块中，使用时需要导入。
参数中function是对sequence中的每个元素累积应用的函数，而initial是在计算中置于sequence元素之前的可选值，并且在sequence为空时用作默认值。

示例代码如下：

from functools import reduce

a = reduce(lambda x, y: x + y, [1, 2, 3, 4])
b = reduce(lambda x, y: x * y, [1, 2, 3, 4], 5)
c = reduce(lambda x, y: x * y + 1, [1, 2, 3, 4], 5)

print(a)
print(b)
print(c)

# 输出
10    # 计算过程：((1+2)+3)+4
120	  # 计算过程：(((5*1)*2)*3)*4
161	  # 计算过程：(((5*1+1)*2+1)*3+1)*4+1

四、sorted()和sort()

sorted函数

sorted(iterable, key=None, reverse=False)

• iterable: 待排序的可迭代对象
• key=None: 接受一个回掉函数，回调函数只能有一个参数，根据函数的返回值进行排序
• reverse=False: 接受一个布尔值，选择是否反转排序结果，默认是升序排列

示例代码如下

a = sorted([1, -2, 5, 3])  # 列表排序
b = sorted({'name': 'python', 'address': 'beijing', 'phone': '12345678'})  # 对字典进行排序时，默认是对字典的key进行排序

c = sorted([3, 7, 5, 2], reverse=True)  # 降序排列

list1 = [('python', 4), ('java', 3), ('c++', 1), ('c', 2)]
d = sorted(list1, key=lambda x: x[1], reverse=True)  # 按照d的第二个元素排序，并将排序结果逆转

print(a)
print(b)
print(c)
print(d)

# 输出
[-2, 1, 3, 5]
['address', 'name', 'phone']
[7, 5, 3, 2]
[('python', 4), ('java', 3), ('c', 2), ('c++', 1)]

sort函数
sorted函数进行排序是生成新的结果，而sort是直接原地修改，是一种in_place原地操作

示例代码如下

list1 = [1, 8, 3, 9]
list2 = [1, 8, 3, 9]

sorted(list1)
list2.sort()

print(list1)
print(list2)

# 输出
[1, 8, 3, 9]  # 使用sorted，原列表没有变
[1, 3, 8, 9]  # 使用sort，原列表变了

五、zip()

zip(*iterables)

zip函数在多迭代器上并行迭代，从每个迭代器返回一个数据项组成一个元祖

示例代码如下

# zip接受单个元素
a = zip([1, 2, 3])  # 传入列表类型
b = zip('python')  # 传入字符串类型
c = zip((1, 2, 3))  # 传入元组类型

# zip接受多个元素
d = zip([1, 2, 3], [4, 5, 6], [7, 8, 9])

print(list(a))
print(list(b))
print(list(c))
print(list(d))

# 输出
[(1,), (2,), (3,)]
[('p',), ('y',), ('t',), ('h',), ('o',), ('n',)]
[(1,), (2,), (3,)]
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]