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
|
# ### 匿名函數(shù) : lambda表達式"""概念: 用一句話來表達只有返回值的函數(shù)語法: lambda 參數(shù) : 返回值特點: 簡潔,高效"""# (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 "偶數(shù)" else: return "奇數(shù)"# 改造func = lambda n : "偶數(shù)" if n % 2 == 0 else "奇數(shù)"print( func(44) )# 三元運算符"""語法: 真值 if 條件表達式 else 假值如果條件表達式成立為True , 返回if前面的真值,反之,返回else后面的假值"""n = 13res = "偶數(shù)" if n % 2 == 0 else "奇數(shù)"print(res)# 小練習 : 比較兩者之間的最大值進行返回def func(x,y): if x > y: return x else: return y# 改造func = lambda x,y : x if x>y else yprint( 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 在函數(shù)外 , 獲取的是打印之前所有的全局變量locals 在函數(shù)內 , 獲取的是調用之前所有的局部變量""""""def func(): a1 = 1 b2 = 2a = 1b = 2res = locals()c = 3print(res)d = 4"""# 2.局部空間"""a = 1b = 2def func(): a1 = 1 b2 = 2 res = locals() c3 = 3 print(res) d4 = 4c = 3func()d = 4"""# 二.globals 只獲取全局空間的全局變量"""globals 在函數(shù)外 , 獲取的是打印之前所有的全局變量globals 在函數(shù)內 , 獲取的是調用之前所有的全局變量"""# 1. 全局空間"""def func(): a1 = 1 b2 = 2a = 1b = 2res = globals()c = 3print(res)d = 4"""# 2.局部空間"""a = 1b = 2def func(): a1 = 1 b2 = 2 res = globals() c3 = 3 print(res) d4 = 4c = 3 func() globals()d = 4"""# ### globals 返回的是內置系統(tǒng)的全局字典"""dic = globals()print(dic)# 通過字符串可以創(chuàng)建全局變量dic["wangwen"] = "18歲"print(wangwen)"""# 批量創(chuàng)建全局變量def func(): dic = globals() for i in range(1,5): # 批量在dic當中添加鍵值對,以創(chuàng)建全局變量 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()函數(shù)調用并不斷返回下一個值的對象稱為迭代器(Iterator 迭代器是對象)概念: 迭代器指的是迭代取值的工具，迭代是一個重復的過程，每次重復都是基于上一次的結果而繼續(xù)的， 單純的重復并不是迭代 特征: 并不依賴索引,而通過next指針(內存地址尋址)迭代所有數(shù)據(jù),一次只取一個值, 而不是一股腦的把所有數(shù)據(jù)放進內存.大大節(jié)省空間,"""# 一.可迭代對象setvar = {"王同培","馬春配","趙萬里","趙沈陽"}# 獲取當前對象的內置成員lst = dir(setvar)print(lst)# 判斷是否是可迭代對象res = "__iter__" in lstprint(res)# for i in setvar: # print(i)# 二.迭代器"""for循環(huán)之所以可以遍歷所有的數(shù)據(jù),是因為底層使用了迭代器,通過地址尋址的方式,一個一個的找數(shù)據(jù);可迭代對象 -> 迭代器 實際上就是從不能夠被next直接調用 -> 可以被next指針直接調用的過程如果是可迭代對象 -> 不一定是迭代器如果是迭代器 -> 一定是可迭代對象"""# 1.如何創(chuàng)建一個迭代器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 forit = iter(setvar)for i in it: print(i)print("<======>")# 2 for + nextit = 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)) # Falseprint(isinstance(range(10),Iterable)) # True# 變成迭代器it = range(10).__iter__()print(isinstance(it,Iterator)) # Trueprint(isinstance(it,Iterable)) # True# 調用it# nextres = next(it)print(res)res = next(it)print(res)print("<=====>")# for + next for i in range(3): print(next(it))print("<=====>")# forfor i in it: print(i) |
小提示：
|
1
2
|
可迭代對象到迭代器就是一個不能被next直接調用到能被next直接調用的過程for循環(huán)底層能表里無序的數(shù)據(jù)就是通過迭代器來實現(xiàn)的 |
4. map高階函數(shù)
|
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
|
# ### 高階函數(shù) : 能夠把函數(shù)當成參數(shù)傳遞的就是高階函數(shù) (map ,filter ,reduce , sorted)# map"""map(func,iterable)功能: 處理數(shù)據(jù) 把iterable中的數(shù)據(jù)一個一個拿出來,扔到func做處理,通過調用迭代器來獲取返回值參數(shù): func : 函數(shù)(內置函數(shù),自定義函數(shù)) iterable : 可迭代性對象 (容器類型數(shù)據(jù),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,Iterableit = map(int,lst)print(isinstance(it,Iterator))"""代碼解析: 第一次調用迭代器 先把列表中的第一個元素"1"拿出來扔到int中做強轉,變成整型1返回出來 第二次調用迭代器 先把列表中的第一個元素"2"拿出來扔到int中做強轉,變成整型2返回出來 第三次調用迭代器 先把列表中的第一個元素"3"拿出來扔到int中做強轉,變成整型3返回出來 第四次調用迭代器 先把列表中的第一個元素"4"拿出來扔到int中做強轉,變成整型4返回出來"""# 1.調用迭代器 nextprint(next(it))print(next(it))print(next(it))print(next(it))# print(next(it)) error# 2.調用迭代器 forprint("<======>")it = map(int,lst)for i in it: print(i)# 3.調用迭代器 for + nextprint("<======>")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 << 4lst = [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 << nit = map(func,lst)print(list(it))"""只有在調用迭代器的時候,才會真正觸發(fā)map函數(shù)中的所有內容;不調用不觸發(fā);強轉迭代器時,把可以調用的所有數(shù)據(jù)都放到列表中第一次調用時: 把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"] = 97print(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 實現(xiàn)字典的翻轉,通過給與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高階函數(shù)
|
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)功能: 計算數(shù)據(jù) 把iterable中的前兩個數(shù)據(jù)扔到func函數(shù)中做計算,把計算的結果和iterable中第三個值在繼續(xù)扔到func中做計算 以此類推 ... 最后返回計算的結果 參數(shù): func: 自定義函數(shù) iterable : 可迭代對象 (容器類型數(shù)據(jù) range對象 迭代器)返回值: 計算的結果"""# (1) [7,7,5,8] => 7758lst = [7,7,5,8]# 方法一strvar = ""for i in lst: strvar += str(i)res = int(strvar)print(res , type(res))# 方法二"""7 * 10 + 7 = 7777 * 10 + 5 = 775775 * 10 + 8 = 7758"""# 1.先變成迭代器it = iter(lst)# 2.取出兩個值num1 = next(it)num2 = next(it)print(num1,num2)# 做計算total = num1 * 10 + num2print(total) # 77# 3.把計算的結果在和剩下的數(shù)據(jù)做計算for num in it: total = total * 10 + num# 4.返回最后的結果print(total , type(total))print("<==========>")# reduce改寫'''從...functools模塊, 引入 .. reduce方法'''from functools import reducelst = [7,7,5,8]def func(x,y): # print(x,y) return x * 10 + yres = reduce(func,lst)print(res)# 使用lambda 進行改造print(reduce(lambda x,y: x*10 + y,lst))# (2) "123" => 123 不使用int的情況下實現(xiàn)該操作;strvar = "123"def func(x,y): return x * 10 + y# 把字符串"123" 處理成數(shù)字的123def 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高階函數(shù)
|
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)功能: 過濾數(shù)據(jù) 在自定義的函數(shù)中, 如果返回True, 該數(shù)據(jù)保留 如果返回False,該數(shù)據(jù)舍棄 參數(shù): func: 自定義函數(shù) iterable : 可迭代對象 (容器類型數(shù)據(jù) range對象 迭代器)返回值: 迭代器"""# 1.只要列表中所有的偶數(shù)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 Falseit = 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高階函數(shù)
|
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=函數(shù),reverse=False)功能:排序數(shù)據(jù)參數(shù): iterable : 可迭代對象 (容器類型數(shù)據(jù) range對象 迭代器) key : 指定函數(shù)(自定義/內置) 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) => 12 => abs(2) => 2-90 => abs(-90) => 90-100 => abs(-100) => 100"""# 4.按照自定義函數(shù)進行排序tup = (19,23,42,87)"""42 % 10 2 => 4223 % 10 3 => 2387 % 10 7 => 8719 % 10 9 => 19"""def func(n): print(n) return n % 10lst = sorted(tup,key = func)print(lst)# 5.任意的容器類型數(shù)據(jù)都可以通過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) 可以排序所有的容器類型數(shù)據(jù) (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_leadername = ['oldboy', 'alex', 'wusir']"""it = map(lambda n : n+"_leader",name)print(list(it))"""# 2.用map來處理下述 listvar ,要求得到新列表,每個元素名字加后面加_leaderlistvar = [{'name':'alex'},{'name':'wusir'}]def func(n): # print(n) # n["name"] + "_leader" # 方法一 # return n["name"] + "_leader" # 方法二 n["name"] += "_leader" return nit = 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] > 20it = 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))# lambdaprint(list(map(lambda n : n["shares"] * n["price"] ,portfolio)))# b.用filter過濾出price大于100的股票。def func(n): if n["price"] > 100: return Trueit = 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
