讲讲Python里的“高阶函数”
高阶函数指的是能接收一个或多个函数作为参数的函数，python中有一些内置的高阶函数，在某些场合使用可以提高代码的效率。
今天我们就来给大家说说几个常用的高阶函数。
一、map函数
map(function, iterable, ...)
返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器。如果传入了额外的 iterable 参数，function 必须接受相同个数的实参并被应用于从所有可迭代对象中并行获取的项。
y, m, d = map(int, input().split('/'))
print(y, m, d)
print(type(y), type(m), type(d))
输入：2020/9/3
结果如下：
2020 9 3
<class 'int'> <class 'int'> <class 'int'>
import math
# 对数据做映射
print(list(map(lambda x: 2 ** x + 1, [1, 3, 5, 7])))
print(list(map(lambda y: math.log10(y), [10, 100, 1000, 10000])))
print(list(map(lambda x, y: x ** 2 + y, [1, 2, 3, 4, 5], [1, 2, 3, 4, 5])))
运行结果如下：
[3, 9, 33, 129]
[1.0, 2.0, 3.0, 4.0]
[2, 6, 12, 20, 30]
再举个简单例子，假设用户输入的英文名字不规范，没有按照首字母大写，后续字母小写的规则
利用map()函数，把一个list（包含若干不规范的英文名字）变成一个包含规范英文名字的list。
输入：['bob', 'LISA', 'barT', 'faker']
输出：['Bob', 'Lisa', 'Bart', 'Faker']
def trans(s):
s = s[0].upper() + s[1:].lower() # 首字母大写 后续字母小写
return s
print(list(map(trans, ['bob', 'LISA', 'barT', 'faker'])))
print(list(map(lambda x: x[0].upper() + x[1:].lower(), ['bob', 'LISA', 'barT', 'faker'])))
运行结果如下：
['Bob', 'Lisa', 'Bart', 'Faker']
['Bob', 'Lisa', 'Bart', 'Faker']
filter(function, iterable) # function为判断函数，iterable为可迭代对象
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。接收的两个参数中，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到迭代器中。如果function 是 None，则会假设它是一个身份函数，即 iterable 中所有返回假的元素会被移除。
lis = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(filter(lambda x: x % 2, lis))) # 符合条件 得到奇数
print(list(filter(lambda y: y % 2 == 0, lis))) # 得到偶数
运行结果如下：
[1, 3, 5, 7, 9]
[2, 4, 6, 8, 10]
# 如果 function 是None，则会假设它是一个身份函数，即 iterable 中所有返回假的元素会被移除。
s = [1, 2, '', [], {}, (), '123']
print(list(filter(None, s)))
运行结果如下：
[1, 2, '123']
# 利用filter函数筛选出水仙花数
# 水仙花数是指一个3位数，它的每个位上的数字的3次幂之和等于它本身（例如：1^3 + 5^3 + 3^3 = 153）
lis = [i for i in range(100, 1001)] # 三位数
# 输出水仙花数
print(list(filter(lambda x: x == sum([int(i) ** 3 for i in str(x)]), lis)))
运行结果如下：
[153, 370, 371, 407]
# filter的应用案例-埃氏筛法求素数
def odd_sequence(): # 构造从3开始的奇数序列
n = 1
while True:
n = n + 2
yield n
def prime_filter(prime_num): # 筛选素数的函数
return lambda x: x % prime_num > 0
def primes():
yield 2 # 先返回第一个素数2，然后利用filter()函数不断产生筛选后的新序列
nums = odd_sequence()
while True:
prime_num = next(nums) # 取出序列第一个数
yield prime_num # 返回序列第一个数
nums = filter(prime_filter(prime_num), nums) # 得到新序列
def main():
for n in primes():
if n < 100000:
print(n)
else:
break
if __name__ == '__main__':
main()
根据 iterable 中的项返回一个新的已排序列表。 具有两个可选参数，它们都必须指定为关键字参数。key：指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。默认值为 None (直接比较元素) reverse：为一个布尔值，如果设为 True，则每个列表元素将按反向顺序比较进行排序
# 学号 姓名 成绩
d = {'001': ['张三', 88], '002': ['李四', 90], '003': ['王五', 73]}
# 按成绩排序 降序 由高到低
d1 = list(sorted(d.items(), key=lambda x: x[1][1], reverse=True))
print('学号 姓名 成绩')
for item in d1:
print(item[0], item[1][0], item[1][1])
运行结果如下：
学号 姓名 成绩
002 李四 90
001 张三 88
003 王五 73
# 输入一组数到列表nums，请找到列表中任意两个元素相加能够等于9的元素，形成一个元组
# 使其小数在前大数在后，如：(2,7),(1,8)。重复的元组元素只保留一个，结果按元组第一个元素从大到小顺序输出
def get_tuple(num_list):
temp_list = []
for i in num_list:
if (9 - i) in num_list:
min_ = (9 - i) if (i >= (9 - i)) else i
max_ = i if min_ == (9 - i) else (9 - i)
if (min_, max_) not in temp_list:
temp_list.append((min_, max_))
return temp_list
nums = input("numbers：")
# 列表推导式
num_list = [int(i) for i in nums.split(',')]
result_list = get_tuple(num_list)
# 按列表里每个元组的第一个元素从大到小排序 降序
result_list = sorted(result_list, key=lambda x: x[0], reverse=True)
print(result_list)
运行结果如下：
numbers：3,4,5,7,2,8,1,6,9,0
[(4, 5), (3, 6), (2, 7), (1, 8), (0, 9)]
四、reduce函数
reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算。返回的是一个计算的最终结果。
from functools import reduce
s = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 做累积计算
print(reduce(lambda x,y: x + y, s))
print(reduce(lambda x,y: 10 * x + y, s))
print(reduce(lambda x,y: str(x) + str(y), s))
运行结果如下：
45
123456789
0123456789
结语
以上就是python中高阶函数的基本用法，希望本文的内容对大家的学习或者工作具有一定的参考学习价值。
如果文章对你有帮助，欢迎转发/点赞/收藏~
作者：叶庭云
_往期文章推荐_
评论