python高级 之(三) --- 高阶函数

高阶函数

 

map函数 

• 简介

 1 """
 2 map(func，*iterables)
 3     参数：一个是函数、一个是序列
 4     作用：将序列中的元素依此作用于函数，将函数运行结果返回
 5          存放于map类型数据中。常用于转化
　　　　注意：存放在map类型的数据中，如果数据被取出，再去取就没有数据了
 6 """
 7 # "拼接符".join(序列)。要求：序列中的内容必须是字符串类型
 8 # 将序列中的整型转换成字符串类型
 9 list0 = [23,45,67]
10 # 方法一
11 new_list = []
12 for ele in list0:
13     new_list.append(str(ele))
14 print(new_list)
15 # 方法二
16 new_list = [str(ele) for ele in list0]
17 print(new_list)
18 # 方法三
19 res = map(str,list0)
20 print(res) # 结果map类型：<map object at 0x10f817c88>
21 new_list = list(map(str,list0))
22 print(new_list)

 1 """
 2 要求：不借助系统方法int、eval，将序列中的内容字符串数据转化为整型类型
 3 """
 4 num_list = ['1','2','3','4','5','6','7','8','9']
 5 # 方法一
 6 res = list(map(int,num_list))
 7 print(res)
 8 # 方法二
 9 res = list(map(eval,num_list))
10 print(res)
11 # 方法三
12 def get_num(num_ch):
13     num_dict = {'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
14     return num_dict[num_ch]
15 res = list(map(get_num,num_list))
16 print(res)

zip函数

• 简介 

1 """
2 zip()
3     参数：是一个个的序列
4     作用：传入的是多个序列，将多个序列中的每个位置元素一一对应进行组合，
5          生成一个新的序列，存放于zip类型的数据中。组合的时候，多数服从少数
6 """
7 res = list(zip((15,23),(45,23,76)))
8 print(res)  # 结果：[(15, 45), (23, 23)]

• 练习

1 # 将字典中的键和值进行颠倒
2 dict0 = {'a':77,'b':88,'c':99}
3 new_dict = {v:k for k,v in dict0.items()}
4 print(new_dict)
5 # 用zip方法
6 new_dict = dict(zip(dict0.values(),dict0.keys()))
7 print(new_dict)

filter函数

• 简介 

 1 """
 2 fliter(func，*iterables) ---> filter object
 3     参数：一个是函数、一个是序列
 4     作用：进行筛选的。将序列中每一个元素 作用于函数中，
 5          根据函数的返回结果为 False 或 True 来进行保留或者去除该元素
 6          如果为True 表示保留该元素；为False 表示去除该元素
 7          如果函数赋予的是None，默认序列中所有的元素都是保留的
 8     过程：将序列中的每一个元素作用于函数，根据函数返回结果为True的情况下，将该数据存放在filter类型容器中
 9 """
10 # 生成一个列表 存放1-10之间的偶数
11 
12 # 普通方法
13 new_list = []
14 for i in range(1,11):
15     if i % 2 == 0:
16         new_list.append(i)
17 print(new_list)
18 # 列表生成式方法
19 new_list = [i for i in range(1,11) if i % 2 == 0]
20 print(new_list)
21 # 用filter方法
22 res = list(filter(lambda a:a % 2 == 0,range(1,11)))
23 print(res)
24 """或者"""
25 def is_even(ele):
26     return ele % 2 == 0
27 res = list(filter(is_even,range(1,11)))
28 print(res)

 1 """
 2 练习：去除掉列表中的空白字符串
 3 """
 4 str_list = ['abc','\n\t','   ','   \t','\tgood\n']
 5 # 方法一
 6 new_list = []
 7 for i in str_list:
 8     if len(i.split()) != 0:
 9         new_list.append(i)
10 print(new_list)
11 # 方法二
12 def filter_space(src_str):
13     return len(src_str.strip())
14 filter_obj = list(filter(filter_space,str_list))
15 print(filter_obj)

 1 """
 2 筛选字典：去除掉字典中不及格的成绩
 3 """
 4 score_dict = {'语文':77,'数学':88,'政治':49,'英语':66,'历史':47}
 5 # 方法一 普通方法
 6 new_dict = {}
 7 for k, v in score_dict.items():
 8     if v >= 60:
 9         new_dict[k] = v
10 print(new_dict)
11 # 方法二 字典生成式
12 new_dict = {k:v for k, v in score_dict.items() if v >= 60}
13 print(new_dict)
14 # 方法三
15 res = filter(lambda item:item[1] >= 60,score_dict.items())
16 new_dict = dict(res)
17 print(new_dict)

sorted函数

•  简介

 1 """
 2 sorted(func，*iterables)
 3     参数：第一个是序列、第二个是key、第三个是reverse
 4     作用：排序的。会新建一个序列，包含原有序列的所有内容.
 5          这种排序没有影响原列表，生成了一个新的列表。其他的和列表中的排序方法一致
 6          key接收的是一个函数，函数返回的是每个元素进行排序时的数据格式。若不传函数，默认以原数据大小进行排序
 7          reverse 默认为False 生序；True为降序
 8 
 9 """
10 list0 = [45,2,765,23,85,2,78]
11 list0.sort(reverse=True) # 列表中原有的排序方式影响的是原列表，没有生成新列表。降序
12 print(list0)
13 
14 # 根据每个元素取反的值进行降序排序
15 list0 = [45,2,765,23,85,2,78]
16 list0.sort(key=lambda ele: -ele,reverse=True)
17 print(list0)
18 
19 # 用sorted()方法
20 list0 = [45,2,765,23,85,2,78]
21 new_list = sorted(list0)
22 print(new_list)
23 print(list0)

• 练习

1 # 不影响原列表 按照年龄对列表进行降序排序
2 dict_list = [{"name":"小明", "age":18},{"name":"小红", "age":17},{"name":"小刚", "age":19}]
3 new_list = sorted(dict_list, key=lambda item:item["age"],reverse=True)
4 print(new_list)

reduce函数

• 简介

 1 """
 2 reduce(func，*iterables)
 3     参数：一个是函数、一个是序列
 4     作用：将序列中的元素进行累计，
 5          第一次传递的是序列中前两个元素进行累计，求出结果
 6          之后每一次 传递的是上一次的累计结果 和 下一个元素进行累计
 7     注意：函数必须接收两个实参，声明的时候得有两个型参
 8 """
 9 from functools import reduce
10 res = reduce(lambda x,y: x*y, [1,2,3,4,5])
11 print(res) # 结果：120

 1 """
 2 编写一个函数，接收两个字符串形式的数字作为参数，以字符串形式返回这两个数字的和
 3 比如：
 4     输入：1，1。返回：2
 5     输入：12，34。返回：46
 6     输入：1，99。返回：100
 7 注意：输入的数字有可能很大，不得直接对参数进行强制类型转换
 8 """
 9 from functools import reduce
10 # 自定义一个方法,将0-9的字符串转换成0-9数字
11 def ch_int(num_ch):
12     num_dict = {'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
13     return num_dict[num_ch]
14 # 自定义一个方法，将连续的多个字符数值转换成整型数据
15 def str_int(x,y):
16     int_x = ch_int(x) # 第一个字符
17     int_y = ch_int(y) # 第二个字符
18     return int_x * 10 + int_y
19 value = reduce(str_int,"99")
20 print(value)
21 # 多位数转换
22 res_1 = list(map(ch_int,"632"))
23 print(res_1)
24 def str0_int(x,y):
25     return x * 10 + y
26 res = reduce(str0_int,res_1)
27 print(res)

• 进阶[经典整合]

 1 """
 2 将上述方法进行整合，完成对字符串数值转换为整型数据
 3 """
 4 from functools import reduce
 5 def str_int(src_str):
 6     # 将每个字符获取其十进制数据
 7     def ch_int(ch):
 8         num_dict = {'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
 9         return num_dict[ch]
10     # 将获取的每一个十进制数据累计成最终的数据整型格式
11     def to_int(x,y):
12         return x * 10 + y
13     # 调用map方法获取每个字符对应的十进制数据
14     obj = map(ch_int,src_str)
15     # 调用累计的方法，将map中每个字符对应的十进制数据累计起来
16     value = reduce(to_int,obj)
17     return value
18 res = str_int("111")
19 print(res)

 

转载于:https://www.cnblogs.com/TMMM/p/11395765.html