一、定义
参数是一个函数的函数 ——> 高阶函数
二、高阶函数
1、abs(n) : 求n的绝对值，并返回给调用处
1 res1 = abs(-609) # 609
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)
原文地址：https://www.cnblogs.com/Tree0108/p/12110150.html
时间： 2024-09-28 16:57:32