一、定义
参数是一个函数的函数 ——> 高阶函数
二、高阶函数
1、abs(n) : 求n的绝对值，并返回给调用处
2、list.sort(key, reverse=False) : 将列表中的每个元素按照指定的规则排序;无返回值,将排序的结果直接作用于原列表
形参key的值是个函数, 这个函数用来指定列表排序的规则
这个函数必须要有一个参数, 这个参数就代表列表中的每个元素
这个函数必须要有一个返回值,这个返回值就是用来比较每个元素排序顺序的
1 list1 = [99, 16, 34, -988, 0.123]
2 list1.sort()
3 print(list1) # [-988, 0.123, 16, 34, 99]
4
5 # 按照绝对值, 由小到大排序
6 list1.sort(key=abs)
7 print(list1) # [0.123, 16, 34, 99, -988]
8
9 # 按照平方的值, 由大到小排序
10 def square(n): # 参数 功能: 求一个数的平方,并把结果返回
11 return n ** 2
12
13 list1.sort(key=square, reverse=True)
14 print(list1) # [-988, 99, 34, 16, 0.123]
3、sorted(iterable, key, reverse) : python内置的排序函数,将iterable中的每个元素按照指定的规则进行排序
将排序的结果形成一个新列表返回给调用处
key和reverse的用法与list.sort()函数一样
1 res2 = sorted(list1, key=abs, reverse=True)
2 print(res2) # [-988, 99, 34, 16, 0.123]
3 print(type(res2)) # <class 'list'>
4、max(, key) : 指定某种规则,获取最大的值对应的元素
max(n1, n2, n3, key) : 对n1, n2, n3按照key进行比较大小, 获取最大的
max(容器, key) : 对容器中的元素按照key进行比较大小, 获取最大的
key这个形参对应的函数：必须要有参数(比较的元素)
必须要有返回值(比较的规则)
1 res3 = max(1, 200, -90)
2 print(res3) # 200
3
4 # 1. 求绝对值最大的那个数
5 res4 = max(1, 200, -999, key=abs)
6 print(res4) # -999
7
8 # 2. 求列表中绝对值最大的那个数
9 list2 = [1, 200, -999]
10 res5 = max(list2, key=abs)
11 print(res5) # -999
1 list3 = [
2 {"name": "Rose", "age": 18},
3 {"name": "Jack", "age": 17},
4 {"name": "Tom", "age": 16},
5 ]
6
7 # 使用max 获取年龄最大的学生的信息
8 # 对谁进行比较, 谁就是指定规则函数中的参数
9 def get_max_age(d): # 指定规则: 比较年龄
10 return d.get('age')
11
12 res6 = max(list3, key=get_max_age) # 形参:key --> 函数(参数->dict)
13 print(res6) # {'name': 'Rose', 'age': 18}
14
15 # 使用max 获取姓名最大的学生的信息
16 def get_max_name(d):
17 return d.get('name')
18
19 res7 = max(list3, key=get_max_name)
20 print(res7) # {'name': 'Tom', 'age': 16}
5、map(function, iterable) : 将可迭代对象中的每个元素应用于key函数, 将key函数执行的结果生成一个新的可迭代对象并返回给调用处
1 list4 = [-2, 8, 2.1, -0.4]
2
3
4 def get_square(n): # 参数: 列表(可迭代对象)中的每一个元素
5 return n ** 2
6
7
8 res8 = map(get_square, list4) # <map object at 0x0000000001E7CA48>
9 print(list(res8)) # [4, 64, 4.41, 0.16000000000000003]
10
11 # 1. 求列表中每个元素对2取余的余数组成系列表
12 def get_nums(n):
13 return n % 2
14
15 res9 = list(map(get_nums, [2, 3, 4, 5]))
16 print(res9)
17
18 # 2. 求列表中每个字符串的首字母大写组成的新列表
19 # str.capitalize 有参数有返回值
20 def get_first_alpha_upper(s): # 参数s 列表中的每个字符串
21 return s.title() # s.isupper() True / False s.upper()
22
23 # res10 = list(map(str.capitalize, ["python", "i", "love", "you"]))
24 res10 = list(map(get_first_alpha_upper, ['python', 'good', 'study']))
25 print(res10)
26
27 # 3. 求两个列表中相同索引值的元素的和组成的新列表
28 list5 = [1, 2, 3, 4, 5]
29 list6 = [10, 10, 10, 10, 10]
30
31 def get_sum(a, b): # a, b分别是每个列表中相同索引值的元素
32 return a + b
33
34 res11 = list(map(get_sum, list5, list6)) # [11, 12, 13, 14, 15]
35 print(res11)
6、filter(function, iterable) : 指定一个规则, 过滤掉可迭代对象中(序列)不符合规则的元素，并将符合规则的元素组成一个新的可迭代对象返回给调用处
function的返回值必须是bool类型, 过滤掉的返回值为False, 保留的返回值为True
1 list7 = ['python', "ABC", "PYTHON", "123aBcDE"]
2
3 # 1. 过滤掉list7中字母全是大写的元素
4 def filter_up_alpha(s): # 功能: 过滤 参数:列表中的每个元素
5 return not s.isupper() # 返回值 必须是bool类型, False:该元素被过滤掉, True: 不被过滤掉
6
7 res12 = list(filter(filter_up_alpha, list7)) # <filter object at 0x00000000021AEA08>
8 print(res12) # ['python', '123aBcDE']
9
10 # 2. 过滤掉list7中字母不全是小写字母组成的元素
11 res13 = list(filter(str.islower, list7)) # str.lower 是否全是由小写字母组成的, 是返回True, 不是返回False
12 print(res13) # ['python']
13
14
15 # 4. 过滤掉列表中的所有偶数 (不要偶数)
16 def get_odd(n): # 参数: 列表中的每个元素
17 if n % 2 == 0:
18 return False
19 else:
20 return True
21
22
23 res14 = list(filter(get_odd, [12, 13, 14, 15, 16]))
24 print(res14)
7、zip(iter1, iter2, ...) 压缩打包 把多个可迭代对象中相同索引值的元素,组成一个元组,然后将所有的元组组成一个新的可迭代对象,返回给调用处
1 list8 = [1, 2, 3, 4]
2 list9 = ["a", "b", "c", "d"]
3
4 """
5 <zip object at 0x00000000026AF588> [(1, "a"), (2, "b"), (3, "c"), (4, "d")]
6 """
7
8 res15 = list(zip(list8, list9)) # [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]
9 print(res15)
10
11 # 应用场景:
12 for x in zip(list8, list9):
13 print(x)