本文采用循序漸進的寫法，逐步遞進.

傳統for迴圈：

#獲取1到1000000的偶數
#採用傳統寫法（俗稱普通解析）
for i in range(1,10**6+1):
 if(i%2==0):
 print(i)
#程式執行結果：
#2
#4
#.
#.
#.
#1000000

總結（從直觀上對程式碼進行評價）：能完成要求，但是程式碼不夠簡潔.

改進後的程式碼，採用列表推導式：

#獲取1到1000000的偶數
#採用列表推導式（俗稱列表解析）
print([i for i in range(1,10**6+1) if i%2==0])
#程式執行結果：
#2
#4
#.
#.
#.
#1000000

我們再來從程式碼執行速度上評價程式碼.

傳統for迴圈的執行速度：

#採用clock（）函式進行測量程式碼執行時間
#用以浮點數計算的秒數返回當前的CPU時間，用來衡量不同程式的耗時，比time.time()更精確
import time
cpu_start=time.clock()
for i in range(1,10**6+1):
 if(i%2==0):
 print(i)
cpu_end=time.clock()
print("程式執行時間:",cpu_end-cpu_start)
#程式執行結果：
#2
#4
#.
#.
#.
#1000000
#程式執行時間: 2.1866424
#注意：編譯器在3.3-3.8之間的會報一個警告：DeprecationWarning: time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead
#因為python3.3以後不被推薦使用，該方法依賴作業系統，建議使用per_counter(返回系統執行時間)或process_time(返回程序執行時間)代替

採用列表推導式的執行速度：

#採用clock（）函式進行測量程式碼執行時間
#用以浮點數計算的秒數返回當前的CPU時間，用來衡量不同程式的耗時，比time.time()更精確
import time
cpu_start=time.clock()
print([i for i in range(1,10**6+1) if i%2==0])
cpu_end=time.clock()
print("程式執行時間:",cpu_end-cpu_start)
#程式執行結果：
#[2,4,6,8...1000000]
#程式執行時間: 0.005884400000000012
#注意：編譯器在3.3-3.8之間的會報一個警告：DeprecationWarning: time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead
#因為python3.3以後不被推薦使用，該方法依賴作業系統，建議使用per_counter(返回系統執行時間)或process_time(返回程序執行時間)代替

總結（從程式碼執行速度上進行評價）：很明顯採用列表推導式的程式碼，執行速度是更勝一籌的.

結論：

1.編譯器會優化，不會因為簡寫而影響效率，反而因優化提高了效率.
2. 減少程式設計師工作量，減少出錯.
3. 即簡化了程式碼,又增強了程式碼的可讀性.

那麼存在列表解析式是否存在集合推導式，字典推導式，元組推導式，我們來一探究竟吧！這裡就不再探究他們的執行速度了！

集合推導式：

#集合推導式
#獲取1到1000000的偶數
x={i for i in range(1,10**6+1) if i%2==0}
type(x)
#輸出結果：
#{2,8...1000000}
#<class 'set'>

字典推導式：

#獲取值是偶數的所有鍵值對形成的字典
#採用傳統方法
dict={'名字1': 1,'名字二': 2,'名字三': 3,'名字四': 4}
dict_x={}
for i,j in dict.items():
  if(j%2==0):
    dict_x[i]=j
print(dict_x)
print(type(dict_x))
#{'名字二': 2,'名字四': 4}
#<class 'dict'>

#獲取值是偶數的所有鍵值對形成的字典
#字典推導式
#方法一
#採用zip函式與for迴圈將兩個列表的值逐步遍歷作為字典的鍵與值
x = {i : j for i,j in zip(["名字1","名字二","名字三","名字四"],[1,2,3,4]) if j%2==0}
print(x)
print(type(x))
#執行結果：
#{'名字二': 2,'名字四': 4}
#<class 'dict'>

#方法二
#獲取值是偶數的所有鍵值對形成的字典
#採用items()函式進行迭代遍歷
dict={'名字1': 1,'名字四': 4}
x = {i : j for i,j in dict.items() if j%2==0}
print(x)
print(type(x))
#執行結果：
#{'名字二': 2,'名字四': 4}
#<class 'dict'>

元組推導式：

#獲取1到1000000的偶數
x=(i for i in range(1,10**6+1) if i%2==0)
print(x)
type(x)
#輸出結果：
#<generator object <genexpr> at 0x00000241FFAB2750>
#<class 'generator'>

咦！前面都返回陣列或者集合或字典，這個怎麼返回了生成器（genexpr）,這是因為元組是不可變的。我們來訪問一下里面的元素把！

#獲取值是偶數的所有鍵值對形成的字典
x=(i for i in range(1,10**6+1) if i%2==0)
for i in x:
 print(i)
#輸出結果：
#2
#4
#.
#.
#.
#1000000

總結：推導式雖然有很多優點，但是唯一不足的就是區域性變數的可讀性不高.

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。