Python全棧迭代器和高階函數怎么使用

本篇內容介紹了“Python全棧迭代器和高階函數怎么使用”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

1. lambda表達式

# ### 匿名函數 : 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

# ### 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. 迭代器

# ### 迭代器
"""
迭代器:
	能被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)

小提示：

可迭代對象到迭代器就是一個不能被next直接調用到能被next直接調用的過程
for循環底層能表里無序的數據就是通過迭代器來實現的

4. map高階函數

# ### 高階函數 : 能夠把函數當成參數傳遞的就是高階函數 (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高階函數

# ### 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高階函數

# ### 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高階函數

# ### 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.用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"]))

“Python全棧迭代器和高階函數怎么使用”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！