服务器之家

服务器之家 > 正文

Python全栈之迭代器和高阶函数

时间：2022-03-11 00:24     来源/作者：熬夜泡枸杞

1. lambda表达式

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# ### 匿名函数 : lambda表达式
"""
概念: 用一句话来表达只有返回值的函数
语法: lambda 参数 : 返回值
特点: 简洁,高效
"""
# (1) 无参的lambda表达式
def func():
    return "文哥是个帅哥"
# 改造
func = lambda : "文哥是个帅哥"
print(  func()  )
 
# (2) 有参的lambda表达式
def func(n):
    return id(n)
# 改造
func = lambda n : id(n)
print( func(100) )
# (3) 带有判断条件的lambda表达式
def func(n):
    if n % 2 == 0:
        return "偶数"
    else:
        return "奇数"
# 改造
func = lambda n : "偶数" if n % 2 == 0 else "奇数"
print( func(44) )
# 三元运算符
"""语法: 真值 if 条件表达式 else 假值
如果条件表达式成立为True , 返回if前面的真值,反之,返回else后面的假值
"""
n = 13
res = "偶数" if n % 2 == 0 else "奇数"
print(res)
 
# 小练习 : 比较两者之间的最大值进行返回
def func(x,y):
    if x > y:
        return x
    else:
        return y
# 改造
func = lambda x,y : x if x>y else y
print(  func(40,30)  )

2. locals和globals

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
# ### locals 与 globals 使用 (了解)
# 一.locals 获取当前作用域所有的变量
# 1.全局空间
"""
locals 在函数外 , 获取的是打印之前所有的全局变量
locals 在函数内 , 获取的是调用之前所有的局部变量
"""
"""
def func():
    a1 = 1
    b2 = 2
a = 1
b = 2
res = locals()
c = 3
print(res)
d = 4
"""
# 2.局部空间
"""
a = 1
b = 2
def func():
    a1 = 1
    b2 = 2
    res = locals()
    c3 = 3
    print(res)
    d4 = 4
c = 3
func()
d = 4
"""
# 二.globals 只获取全局空间的全局变量
"""
globals 在函数外 , 获取的是打印之前所有的全局变量
globals 在函数内 , 获取的是调用之前所有的全局变量
"""
# 1. 全局空间
"""
def func():
    a1 = 1
    b2 = 2
a = 1
b = 2
res = globals()
c = 3
print(res)
d = 4
"""
# 2.局部空间
"""
a = 1
b = 2
def func():
    a1 = 1
    b2 = 2
    res = globals()
    c3 = 3
    print(res)
    d4 = 4
c = 3
func() globals()
d = 4
"""
# ### globals  返回的是内置系统的全局字典
"""
dic = globals()
print(dic)
# 通过字符串可以创建全局变量
dic["wangwen"] = "18岁"
print(wangwen)
"""
# 批量创建全局变量
def func():
    dic = globals()
    for i in range(1,5):
        # 批量在dic当中添加键值对,以创建全局变量
        dic[ "a%d" % (i) ] = i
        """
        dic["a1"] = 1
        dic["a2"] = 2
        dic["a3"] = 3
        dic["a4"] = 4
        """
func()
print(a1,a2,a3,a4)

3. 迭代器

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
# ### 迭代器
"""
迭代器:
    能被next()函数调用并不断返回下一个值的对象称为迭代器(Iterator  迭代器是对象)
概念:
    迭代器指的是迭代取值的工具，迭代是一个重复的过程，每次重复都是基于上一次的结果而继续的，
    单纯的重复并不是迭代 
特征:
    并不依赖索引,而通过next指针(内存地址寻址)迭代所有数据,一次只取一个值,
    而不是一股脑的把所有数据放进内存.大大节省空间,
"""
# 一.可迭代对象
setvar = {"王同培","马春配","赵万里","赵沈阳"}
# 获取当前对象的内置成员
lst = dir(setvar)
print(lst)
# 判断是否是可迭代对象
res = "__iter__" in lst
print(res)
# for i in setvar:
    # print(i)
# 二.迭代器
"""
for循环之所以可以遍历所有的数据,是因为底层使用了迭代器,通过地址寻址的方式,一个一个的找数据;
可迭代对象 -> 迭代器  实际上就是从不能够被next直接调用 -> 可以被next指针直接调用的过程
如果是可迭代对象 -> 不一定是迭代器
如果是迭代器     -> 一定是可迭代对象
"""
# 1.如何创建一个迭代器
setvar = {"王同培","马春配","赵万里","赵沈阳"}
it = iter(setvar)
print(it)
# 2.如何判断一个迭代器
print(dir(it))
res = "__iter__" in dir(it)  and "__next__" in dir(it)
print(res)
# 3.如何调用一个迭代器
"""next是单向不可逆的过程,一条路走到黑"""
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res)
# res = next(it)
# print(res)
# 4.重置迭代器
it = iter(setvar)
print(  it.__next__()  )
print(  it.__next__()  )
print(  it.__next__()  )
print(  it.__next__()  )
# 5.调用迭代器的其他方法
# 1 for
it = iter(setvar)
for i  in  it:
    print(i)
print("<======>")
# 2 for + next
it = iter(setvar)
for i in range(2):
    print( next(it) )
print( next(it) )
print( next(it) )
# print( next(it) ) error  超出了寻址范围
# 6.判断迭代器/可迭代对象的其他方法
# 从...模块 引入...内容
from collections import Iterator, Iterable
"""Iterator 迭代器 Iterable 可迭代的对象"""
res = isinstance(it,Iterator)
print(res)
res = isinstance(it,Iterable)
print(res)
# 7.range是迭代器么?
print(isinstance(range(10),Iterator)) # False
print(isinstance(range(10),Iterable)) # True
# 变成迭代器
it = range(10).__iter__()
print(isinstance(it,Iterator)) # True
print(isinstance(it,Iterable)) # True
# 调用it
# next
res = next(it)
print(res)
res = next(it)
print(res)
print("<=====>")
# for + next
for i in range(3):
    print(next(it))
print("<=====>")
# for
for i in it:
    print(i)

小提示：

?
1
2
可迭代对象到迭代器就是一个不能被next直接调用到能被next直接调用的过程
for循环底层能表里无序的数据就是通过迭代器来实现的

4. map高阶函数

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
# ### 高阶函数 : 能够把函数当成参数传递的就是高阶函数 (map ,filter ,reduce , sorted)
# map
"""
map(func,iterable)
功能: 处理数据
    把iterable中的数据一个一个拿出来,扔到func做处理,通过调用迭代器来获取返回值
参数:
    func : 函数(内置函数,自定义函数)
    iterable : 可迭代性对象 (容器类型数据,range对象,迭代器)
返回值:
    迭代器
"""
# (1) 把列表中的元素都变成整型
lst = ["1","2","3","4"]
lst_new = []
for i in lst:
    lst_new.append(int(i))
print(lst_new)
# 用map改写
from collections import Iterator,Iterable
it = map(int,lst)
print(isinstance(it,Iterator))
"""
代码解析:
    第一次调用迭代器
        先把列表中的第一个元素"1"拿出来扔到int中做强转,变成整型1返回出来
    第二次调用迭代器
        先把列表中的第一个元素"2"拿出来扔到int中做强转,变成整型2返回出来
    第三次调用迭代器
        先把列表中的第一个元素"3"拿出来扔到int中做强转,变成整型3返回出来
    第四次调用迭代器
        先把列表中的第一个元素"4"拿出来扔到int中做强转,变成整型4返回出来
"""
# 1.调用迭代器 next
print(next(it))
print(next(it))
print(next(it))
print(next(it))
# print(next(it)) error
# 2.调用迭代器 for
print("<======>")
it = map(int,lst)
for i in it:
    print(i)
# 3.调用迭代器 for + next
print("<======>")
it = map(int,lst)
for i in range(3):
    print(next(it))
# 4.强转迭代器 => 列表
it = map(int,lst)
print(list(it))
# (2) [1,2,3,4] => [2,8,24,64]
# print(1 * 2 ** 1)
# print(2 * 2 ** 2)
# print(3 * 2 ** 3)
# print(4 * 2 ** 4)
# 1 << 1
# 2 << 2
# 3 << 3
# 4 << 4
lst = [1,2,3,4]
lst_new = []
for i in lst:
    lst_new.append(i << i)
print(lst_new)
# map改写
def func(n):
    print(1111)
    return n << n
it = map(func,lst)
print(list(it))
"""
只有在调用迭代器的时候,才会真正触发map函数中的所有内容;不调用不触发;
强转迭代器时,把可以调用的所有数据都放到列表中
第一次调用时:
    把1拿出来,扔func当中做处理,返回2,
第二次调用时:
    把2拿出来,扔func当中做处理,返回8,
第三次调用时:
    把3拿出来,扔func当中做处理,返回24,
第四次调用时:
    把4拿出来,扔func当中做处理,返回64,
到此列表[2,8,24,64]
注意点:形参和返回值必须写;
"""
    
# (3) 给你一个列表["a","b","c"] => [97,98,99]
# 字典的键值翻转操作
dic = {97:"a",98:"b",99:"c"}
dic_new = {}
for k,v in dic.items():
    # print(k,v) # 97 a | 98 b | 99 c
    dic_new[v] = k # dic_new["a"] = 97
print(dic_new)
lst = ["a","b","c"]
lst_new = []
for i in lst:
    lst_new.append(dic_new[i])
print(lst_new)
# map改写
print("<========================>")
lst = ["a","b","c"]
lst = ["c","b","a"]
lst = ("c","b","a")
# func 实现字典的翻转,通过给与a,b,c三个键,得到对应的ascii码,通过list强转得到列表
def func(n):
    print(n)
    dic = {97:"a",98:"b",99:"c"}
    dic_new = {}
    for k,v in dic.items():
        dic_new[v] = k
    print(dic_new) # {'a': 97, 'b': 98, 'c': 99}
    return dic_new[n]
        
it = map(func,lst)
print(list(it))

5. reduce高阶函数

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
# ### reduce
"""
reduce(func,iterable)
功能: 计算数据
    把iterable中的前两个数据扔到func函数中做计算,把计算的结果和iterable中第三个值在继续扔到func中做计算
    以此类推 ...
    最后返回计算的结果
参数:
    func: 自定义函数
    iterable : 可迭代对象 (容器类型数据 range对象 迭代器)
返回值:
    计算的结果
"""
# (1) [7,7,5,8] => 7758
lst = [7,7,5,8]
# 方法一
strvar = ""
for i in lst:
    strvar += str(i)
res = int(strvar)
print(res , type(res))
# 方法二
"""
7 * 10 + 7 = 77
77 * 10 + 5 = 775
775 * 10 + 8 = 7758
"""
# 1.先变成迭代器
it = iter(lst)
# 2.取出两个值
num1 = next(it)
num2 = next(it)
print(num1,num2)
# 做计算
total = num1 * 10 + num2
print(total) # 77
# 3.把计算的结果在和剩下的数据做计算
for num in it:
    total = total * 10 + num
# 4.返回最后的结果
print(total , type(total))
 
print("<==========>")
# reduce改写
'''从...functools模块, 引入 .. reduce方法'''
from functools import reduce
lst = [7,7,5,8]
def func(x,y):
    # print(x,y)
    return x * 10 + y
res = reduce(func,lst)
print(res)
# 使用lambda 进行改造
print(reduce(lambda x,y: x*10 + y,lst))
 
# (2) "123" => 123 不使用int的情况下实现该操作;
strvar = "123"
def func(x,y):
    return x * 10 + y
# 把字符串"123" 处理成数字的123
def func2(n):
    # dic = {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}
    dic = {}
    for i in range(10):
        dic[str(i)] = i
    return dic[n]
it = map(func2,strvar)
# res = reduce(func,it)
# print(res,type(res))
# 简写
print(reduce(lambda x,y: x*10 + y,it))

6. filter高阶函数

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# ### filter
"""
filter(func,iterable)
功能: 过滤数据
    在自定义的函数中,
        如果返回True, 该数据保留
        如果返回False,该数据舍弃            
参数:
    func: 自定义函数
    iterable : 可迭代对象 (容器类型数据 range对象 迭代器)
返回值:
    迭代器
"""
# 1.只要列表中所有的偶数
lst = [1,2,34,5,65,6,56,7,56,756,7567,11]
lst_new = []
for i in lst:
    if i % 2 == 0 :
        lst_new.append(i)
print(lst_new)
# filter改写
def func(n):
    if n % 2 == 0:
        return True
    else:
        return False
it = filter(func,lst)
print(list(it))
# 使用lambda 改写
it = filter(lambda n :True if n % 2 == 0 else False , lst)
print(list(it))
print(list(filter(lambda n :True if n % 2 == 0 else False , lst)))

7. sorted高阶函数

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
# ### sorted
"""
sorted(iterable,key=函数,reverse=False)
功能:排序数据
参数:
    iterable : 可迭代对象 (容器类型数据 range对象 迭代器)
    key      : 指定函数(自定义/内置)
    reverse  : 是否倒序
返回值:
    列表
"""
tup = (-90,89,78,3)
# 1.从小到大
res = sorted(tup)
print(res,type(res))
# 2.从大到小
res = sorted(tup,reverse = True)
print(res,type(res))
# 3.按照绝对值进行排序
tup = (-90,-100,1,2)
res = sorted(tup,key=abs)
print(res)
"""
1 => abs(1) => 1
2 => abs(2) => 2
-90 => abs(-90) => 90
-100 => abs(-100) => 100
"""
# 4.按照自定义函数进行排序
tup = (19,23,42,87)
"""
42 % 10 2 => 42
23 % 10 3 => 23
87 % 10 7 => 87
19 % 10 9 => 19
"""
def func(n):
    print(n)
    return n % 10
lst = sorted(tup,key = func)
print(lst)
# 5.任意的容器类型数据都可以通过sorted排序
container = "abc"
container = [1,2,3]
container = (1,2,3)
container = {"你好","王文","你真帅"}
container = {"caixukun","xiaozhan","zhaoshenyang","wangyibo"}
container = {"ww":"英俊帅气","zxy":"猥琐抠脚","zwl":"斯文败类"} # 排的是字典的键
print(sorted(container))
"""
# 总结:
sorted (推荐使用sorted)
    (1) 可以排序所有的容器类型数据
    (2) 返回一个新的列表
sort
    (1) 只能排序列表
    (2) 基于原来的列表进行排序
"""

8. 小练习

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
# 1.用map来处理字符串列表,把列表中所有人都变成 leader ,比方alex_leader
name = ['oldboy', 'alex', 'wusir']
"""
it = map(lambda n : n+"_leader",name)
print(list(it))
"""
# 2.用map来处理下述 listvar ,要求得到新列表,每个元素名字加后面加_leader
listvar = [{'name':'alex'},{'name':'wusir'}]
def func(n):
    # print(n)
    # n["name"] + "_leader"
    # 方法一
    # return n["name"] + "_leader"
    # 方法二
    n["name"] += "_leader"
    return n
it = map(func,listvar)
print(list(it))
# 3.用filter来处理,得到股票价格大于20的股票名字
shares={
    'IBM':36.6,
    'Lenovo':23.2,
    'oldboy':21.2,
        'ocean':10.2,
    }
# 方法一
def func(n):
    if shares[n] > 20:
        return True
    else:
        return False
# 方法二
def func(n):
    if shares[n] > 20:
        return True
# 方法三
def func(n):
    return shares[n] > 20
it = filter(func,shares)
print(list(it))
# 方法四
print(list(filter(lambda n : shares[n] > 20,shares)))
 
# 4.有下面字典:
portfolio=[
    {'name':'IBM','shares':100,'price':91.1},
    {'name':'AAPL','shares':20,'price':54.0},
    {'name':'FB','shares':200,'price':21.09},
    {'name':'HPQ','shares':35,'price':31.75},
    {'name':'YHOO','shares':45,'price':16.35},
    {'name':'ACME','shares':75,'price':115.65}
]
# a.获取购买每只股票的总价格(乘积),迭代器中[9110.0, 1080.0 ,......]
def func(n):
    return n["shares"] * n["price"]
it = map(func,portfolio)
print(list(it))
# lambda
print(list(map(lambda n : n["shares"] * n["price"] ,portfolio)))
# b.用filter过滤出price大于100的股票。
def func(n):
    if n["price"] > 100:
        return True
it = filter(func,portfolio)
print(list(it))
# 方法二
print(list(filter(lambda n : n["price"] > 100 , portfolio )))
# 5.将listvar 按照列表中的每个字典的values大小进行排序,形成一个新的列表。
listvar = [
    {'sales_volumn': 0},
    {'sales_volumn': 108},
    {'sales_volumn': 337},
    {'sales_volumn': 475},
    {'sales_volumn': 396},
    {'sales_volumn': 172},
    {'sales_volumn': 9},
    {'sales_volumn': 58},
    {'sales_volumn': 272},
    {'sales_volumn': 456},
    {'sales_volumn': 440},
    {'sales_volumn': 239}
]
def func(n):
    return n["sales_volumn"]
lst = sorted(listvar,key=func)
print(lst)
# 方法二
print(sorted(listvar,key=lambda n : n["sales_volumn"]))

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注服务器之家的更多内容!

原文链接：https://blog.csdn.net/weixin_46818279/article/details/121067276

标签：
Python 迭代器 高阶函数 

相关文章

热门资讯

2022年最旺的微信头像大全 微信头像2022年最新版图片
2022年最旺的微信头像大全 微信头像2022年最新版图片 2022-01-10
蜘蛛侠3英雄无归3正片免费播放 蜘蛛侠3在线观看免费高清完整
蜘蛛侠3英雄无归3正片免费播放 蜘蛛侠3在线观看免费高清完整 2021-08-24
背刺什么意思 网络词语背刺是什么梗
背刺什么意思 网络词语背刺是什么梗 2020-05-22
yue是什么意思 网络流行语yue了是什么梗
yue是什么意思 网络流行语yue了是什么梗 2020-10-11
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全 2019-12-26
返回顶部