推導式
什麼是推導式
推導式是 for 循環的簡化使用方法，使用推導式，将一個可疊代對象中的資料周遊到某一個容器當中。簡單的來說就是用一行for循環語句，周遊一個可疊代對象中的所有資料，然後将周遊出來的資料進行處理放入對應的容器中的一個過程和方式。
和推導類似作用的還有三元運算符，三元運算符是條件判斷語句的簡化使用方法。
文法
val for val in Iterable
就是
存入容器中的資料
+
for循環語句
表達方式
推導式有三種表達方式，分别用對應的符号包裹推導式語句。
清單推導試：[val for val in Iterable]
集合推導式：{val for val in Iterable}
字典推導式：{x,y for x,y in Iterable}
清單推導式
清單推到式，周遊出來的資料最終就會變成一個清單資料。
基本文法
清單中存入10條資料。
# 正常寫法
lst = []
for i in range(1, 11):
lst.append(i)
print(lst) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 推導式寫法
lst = [i for i in range(1, 11)]
print(lst) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
其它使用方法
單循環推導式
# 處理容器中的資料：[1, 2, 3, 4, 5] -> [3, 6, 9, 12, 15]
lst = [1, 2, 3, 4, 5]
# 普通寫法
new_lst = []
for i in lst:
res = i * 3
new_lst.append(res)
print(new_lst) # [3, 6, 9, 12, 15]
# 推導式寫法
new_lst = [i * 3 for i in lst]
print(new_lst) # [3, 6, 9, 12, 15]
帶有判斷條件的單循環推導式
# 過濾出奇數
lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 普通寫法
new_lst = []
for i in lst:
if i % 2 == 1:
new_lst.append(i)
print(new_lst) # [1, 3, 5, 7, 9]
# 推導式寫法
# 推導式使用單項分支隻能是在for語句結束之後使用
new_lst = [i for i in lst if i % 2 == 1]
print(new_lst) # [1, 3, 5, 7, 9]
多循環推導式
# 兩個清單中的資料相加求和
lst = [1, 2, 3]
lst1 = [11, 22, 33]
# 普通方法
new_lst = []
for i in lst:
for j in lst1:
res = i + j
new_lst.append(res)
print(new_lst) # [12, 23, 34, 13, 24, 35, 14, 25, 36]
# 推導式寫法
new_lst = [i + j for i in lst for j in lst1]
print(new_lst) # [12, 23, 34, 13, 24, 35, 14, 25, 36]
清單推導式練習題
1、将字典中的資料變成['x=A', 'y=B', 'z=c']的樣式
{'x': 'A', 'y': 'B', 'z': 'C' }
2、将所用元素變成純小寫
["ADDD","dddDD","DDaa","sss"]
3、x是0-5之間的偶數,y是0-5之間的奇數 把x,y組成一起變成元組,放到清單當中
4、使用清單推導式 制作所有99乘法表中的運算
5、求M,N中矩陣和元素的乘積
M = [[1,2,3], [4,5,6], [7,8,9]]
N = [[2,2,2], [3,3,3], [4,4,4]]
# 第五題解法之一
# =>實作效果1 [2, 4, 6, 12, 15, 18, 28, 32, 36]
# =>實作效果2 [[2, 4, 6], [12, 15, 18], [28, 32, 36]]
# 實作效果 1
lst_new = []
for i in range(len(M)) :
for j in range(len(N)) :
res = M[i][j] * N[i][j]
lst_new.append(res)
print(lst_new)
# 推導式寫法
res = [M[i][j]*N[i][j] for i in range(len(M)) for j in range(len(N))]
print(res)
# 實作效果 2
lst_new = []
for i in range(len(M)) :
lst_new2 = []
for j in range(len(N)) :
res = M[i][j] * N[i][j]
lst_new2.append(res)
lst_new.append(lst_new2)
print(lst_new)
# 推導式寫法
res = [[M[i][j]*N[i][j] for j in range(len(M))] for i in range(len(N))]
print(res)
集合推導式
集合推導式和清單推導式的用法基本一樣，但是外面使用大括号包括，得到的資料是一個集合。
例題
'''
案例：
滿足年齡在18到21，存款大于等于5000，小于等于5500的人
開卡格式為：尊貴V國際電話預付卡老X（姓氏），否則開卡格式為：摳腳大漢老X（姓氏）
把開卡的種類統計出來
'''
lst = [
{"name": "劉鑫炜", "age": 18, "money": 10000},
{"name": "劉聰", "age": 19, "money": 5100},
{"name": "劉子豪", "age": 20, "money": 4800},
{"name": "孔祥群", "age": 21, "money": 2000},
{"name": "宋雲傑", "age": 18, "money": 20}
]
# 正常寫法
setvar = set()
for i in lst:
if (18 <= i['age'] <= 21) and (5000 <= i['money'] <= 5500):
res = '尊貴VIP老' + i['name'][0]
else:
res = '摳腳老漢' + i['name'][0]
setvar.add(res)
print(setvar) # {'尊貴VIP老劉', '摳腳老漢劉', '摳腳老漢孔', '摳腳老漢宋'}
# 列印顯示隻有4個元素，是因為集合的自動去重
# 使用集合推導式
# 推導式隻能使用單項分支，但是可以在傳回值使用三元運算符
setvar = {
"尊貴V國際電話預付卡老" + i["name"][0] if 18 <= i["age"] <= 21 and 5000 <= i["money"] <= 5500 else "摳腳大漢卡老" + i["name"][0] for i in lst}
print(setvar) # {'摳腳大漢卡老孔', '摳腳大漢卡老劉', '尊貴V國際電話預付卡老劉', '摳腳大漢卡老宋'}
字典推導式
字典推導式也是一樣的用法，但是字典的資料是以鍵值對的形式存在的，是以傳回的資料、或者要将傳回的資料變成兩個，以對應鍵值。
基礎文法
将清單中的鍵值對的變成一個字典
lst = [{'A': 'a'}, {'B': 'b'}]
dct = {k:v for i in lst for k,v in i.items()}
print(dct) # {'A': 'a', 'B': 'b'}
字典推導式常用以配合的函數
| 函數 | 作用 |
|---|---|
| enumerate | 枚舉，根據索引号碼将可疊代對象中的值一一配對成元組，傳回疊代器。 |
| zip | 将多個可疊代對象中的值一一對應組成元組，傳回疊代器。 |
enumerate
功能
枚舉，根據索引号碼 和 Iterable 中的值，一個一個拿出來配對組成元組，放入疊代器中，然後傳回疊代器。
文法
enumerate(iterable, [start = 0])
參數
iterable：可疊代資料
start：可以選擇開始的索引号（預設從0開始索引）
傳回值
疊代器
基本文法
from collections import Iterator
lst = ['東', '南', '西', '北']
# 基本使用
it = enumerate(lst) # 實作功能傳回疊代器
print(isinstance(it, Iterator)) # True
# 強轉成清單
new_lst = list(it)
print(new_lst) # [(0, '東'), (1, '南'), (2, '西'), (3, '北')]
"""
可以看到裡面的元清單中的資料和對應的索引号碼一一對應成了元組
"""
上面的舉例當中，如果使用字典推導式和enumerate函數配合，就可以用一句話達成組成一個字典的目的。
from collections import Iterator
lst = ['東', '南', '西', '北']
# enumerate 配合使用字典推導式 變成字典
dct = {k: v for k, v in enumerate(lst)}
print(dct) # {0: '東', 1: '南', 2: '西', 3: '北'}
zip
功能
将多個Iterable中的值，一個一個拿出來配對組成元組放入疊代器中，如果某個元素多出，沒有比對項就會被舍棄。
文法
zip(iterable, iterable1, ……)
參數就是一個個的可疊代對象。
傳回值
疊代器
基本文法
下面的舉例當中，将三個清單中的元素以一一對應組成元組，但是最小的清單中隻有三個元素，是以隻能一一對應組成三對元組，而多出的元素就被舍棄。
lst1 = [1, 2, 3, 4, 5]
lst2 = ['a', 'b', 'c', 'd']
lst3 = ['A', 'B', 'C']
it = zip(lst1, lst2, lst3)
lst = list(it)
print(lst) # [(1, 'a', 'A'), (2, 'b', 'B'), (3, 'c', 'C')]
為什麼沒有元組推導式
推導式我們到此學習完了，但是我們就發現，推導式就是在容器中使用一個for循環而已，為什麼沒有元組推導式？
請見生成器
優先使用推導式
在有的時候，我們需要在一個清單或者其它的一些容器中存放大量的值，我們一般會怎麼使用呢？比如在初始化一個清單的時候我們使用for循環和append的方法去建立嗎？
這裡大家注意，如果條件允許的話，那麼我們一定是要優先使用推導式而不是for循環加append的方式，原因很簡單，因為底層邏輯的不同，使推導式的執行速度相比for循環加append更快。
import time
# 清單循環插入資料
start_time = time.perf_counter()
lst = []
for i in range(15000000):
lst.append(i)
end_time = time.perf_counter()
print(end_time - start_time) # 1.7453036000000002
""" 推導式比循環速度更快 """
start_time = time.perf_counter()
new_lst1 = [i for i in range(15000000)]
end_time = time.perf_counter()
print(end_time - start_time) # 0.7337192000000001
經過測試我們可以看到，推導式的速度大約是for循環的2倍多，是什麼導緻的？還記得我們之前使用過的
dis
子產品嗎？
import dis
def loop():
lst = []
for i in range(10):
lst.append(i)
return lst
def der():
lst = [i for i in range(10)]
return lst
dis.dis(loop)
print('-' * 100)
dis.dis(der)
結果如下：
4 0 BUILD_LIST 0
2 STORE_FAST 0 (lst)
5 4 SETUP_LOOP 26 (to 32)
6 LOAD_GLOBAL 0 (range)
8 LOAD_CONST 1 (10)
10 CALL_FUNCTION 1
12 GET_ITER
>> 14 FOR_ITER 14 (to 30)
16 STORE_FAST 1 (i)
6 18 LOAD_FAST 0 (lst)
20 LOAD_ATTR 1 (append)
22 LOAD_FAST 1 (i)
24 CALL_FUNCTION 1
26 POP_TOP
28 JUMP_ABSOLUTE 14
>> 30 POP_BLOCK
7 >> 32 LOAD_FAST 0 (lst)
34 RETURN_VALUE
-----------------------------------------------------------------------------
11 0 LOAD_CONST 1 (<code object <listcomp> at 0x000002C71AD950C0, file "tset.py", line 11>)
2 LOAD_CONST 2 ('der.<locals>.<listcomp>')
4 MAKE_FUNCTION 0
6 LOAD_GLOBAL 0 (range)
8 LOAD_CONST 3 (10)
10 CALL_FUNCTION 1
12 GET_ITER
14 CALL_FUNCTION 1
16 STORE_FAST 0 (lst)
12 18 LOAD_FAST 0 (lst)
20 RETURN_VALUE
![TestLink導出用例轉換工具(XML2Excel)[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)