Python之列表生成式、生成器、可迭代對象與迭代器

時間  2019-11-19
標籤 python 列表 生成 成器 迭代 對象 欄目 Python 简体版
原文   原文鏈接

本節內容

  • 語法糖的概念
  • 列表生成式
  • 生成器（Generator）
  • 可迭代對象（Iterable）
  • 迭代器（Iterator）
  • Iterable、Iterator與Generator之間的關係

1、語法糖的概念

「語法糖」，從字面上看應該是一種語法。「糖」，能夠理解爲簡單、簡潔。其實咱們也已經意識到，沒有這些被稱爲「語法糖」的語法，咱們也能實現相應的功能，而 「語法糖」使咱們能夠更加簡潔、快速的實現這些功能。 只是Python解釋器會把這些特定格式的語法翻譯成本來那樣複雜的代碼邏輯而已，沒有什麼過高深的東西。html

到目前爲止，咱們使用和介紹過的語法糖有：算法

  • if...else 三元表達式： 能夠簡化分支判斷語句，如 x = y.lower() if isinstance(y, str) else y
  • with語句： 用於文件操做時，能夠幫咱們自動關閉文件對象，使代碼變得簡潔；
  • 裝飾器： 能夠在不改變函數代碼及函數調用方式的前提下，爲函數增長加強性功能；

這裏會再介紹兩個：app

  • 列表生成式： 用於生成一個新的列表
  • 生成器： 用於「惰性」地生成一個無限序列

2、列表生成式

顧名思義，列表生成式就是一個用來生成列表的特定語法形式的表達式。函數

1. 語法格式：

基礎語法格式

[exp for iter_var in iterable]

工做過程：翻譯

  • 迭代iterable中的每一個元素；
  • 每次迭代都先把結果賦值給iter_var，而後經過exp獲得一個新的計算值；
  • 最後把全部經過exp獲得的計算值以一個新列表的形式返回。

至關於這樣的過程：code

L = []
for iter_var in iterable:
    L.append(exp)

帶過濾功能語法格式

[exp for iter_var in iterable if_exp]

工做過程：htm

  • 迭代iterable中的每一個元素，每次迭代都先判斷if_exp表達式結果爲真，若是爲真則進行下一步，若是爲假則進行下一次迭代；
  • 把迭代結果賦值給iter_var，而後經過exp獲得一個新的計算值；
  • 最後把全部經過exp獲得的計算值以一個新列表的形式返回。

至關於這樣的過程：對象

L = []
for iter_var in iterable:
    if_exp:
        L.append(exp)

循環嵌套語法格式

[exp for iter_var_A in iterable_A for iter_var_B in iterable_B]

工做過程：
每迭代iterable_A中的一個元素，就把ierable_B中的全部元素都迭代一遍。blog

至關於這樣的過程：內存

L = []
for iter_var_A in iterable_A:
    for iter_var_B in iterable_B:
        L.append(exp)

2. 應用場景

其實列表生成式也是Python中的一種「語法糖」，也就是說列表生成式應該是Python提供的一種生成列表的簡潔形式，應用列表生成式能夠快速生成一個新的list。它最主要的應用場景是：根據已存在的可迭代對象推導出一個新的list。

3. 使用實例

咱們能夠對幾個生成列表的要求分別經過「不使用列表生成式」和「使用列表生成式」來實現，而後作個對比總結。

實例1：生成一個從3到10的數字列表

# 不使用列表生成式實現
list1 = list(range(3, 11))

# 使用列表生成式實現
list2 = [x for x in range(3, 11)]

實例2：生成一個2n+1的數字列表，n爲從3到11的數字

# 不使用列表生成式實現
list3 = []
for n in range(3, 11):
    list3.append(2*n + 1)

# 使用列表生成式實現
list4 = [2*n + 1 for n in range(3, 11)]

實例3：過濾出一個指定的數字列表中值大於20的元素

L = [3， 7， 11， 14，19， 33， 26， 57， 99]
# 不使用列表生成式實現
list5 = []
for x in L:
    if x < 20:
        list5.append(x)

# 使用列表生成式實現
list6 = [x for x in L if x > 20]

實例4：計算兩個集合的全排列，並將結果做爲保存至一個新的列表中

L1 = ['香蕉', '蘋果', '橙子']
L2 = ['可樂', '牛奶']

# 不使用列表生成式實現
list7 = []
for x in L1:
    for y in L2:
        list7.append((x, y))

# 使用列表生成式實現
list8 = [(x, y) for x in L1 for y in L2]

實例5：將一個字典轉換成由一組元組組成的列表，元組的格式爲(key, value)

D = {'Tom': 15, 'Jerry': 18, 'Peter': 13}

# 不使用列表生成式實現
list9 = []
for k, v in D.items():
    list9.append((k, v))

# 使用列表生成式實現
list10 = [(k, v) for k, v in D.items()]

可見，使用列表生成式確實要方便、簡潔不少，使用一行代碼就搞定了。

4. 列表生成式與map()、filter()等高階函數功能對比

我以爲，你們應該已經發現這裏說的列表生成式的功能與以前 這篇文章 中講到的map()和filter()高階函數的功能很像，好比下面兩個例子：

實例1：把一個列表中全部的字符串轉換成小寫，非字符串元素原樣保留

L = ['TOM', 'Peter', 10, 'Jerry']
# 用列表生成式實現
list1 = [x.lower() if isinstance(x, str) else x for x in L]

# 用map()函數實現
list2 = list(map(lambda x: x.lower() if isinstance(x, str) else x,  L))

實例2：把一個列表中全部的字符串轉換成小寫，非字符串元素移除

L = ['TOM', 'Peter', 10, 'Jerry']
# 用列表生成式實現
list3 = [x.lower() for x in L if isinstance(x, str)]

# 用map()和filter()函數實現
list4 = list(map(lambda x: x.lower(), filter(lambda x: isinstance(x, str), L)))

對於大部分需求來說，使用列表生成式和使用高階函數都能實現。可是map()和filter()等一些高階函數在Python3中的返回值類型變成了Iteraotr（迭代器）對象（在Python2中的返回值類型爲list），這對於那些元素數量很大或無限的可迭代對象來講顯然是更合適的，由於能夠避免沒必要要的內存空間浪費。關於迭代器的概念，下面會單獨進行說明。

3、生成器（Generator）

從名字上來看，生成器應該是用來生成數據的。

1. 生成器的做用

按照某種算法不斷生成新的數據，直到知足某一個指定的條件結束。

2. 生成器的構造方式

構造生成器的兩種方式：

  • 使用相似列表生成式的方式生成 (2*n + 1 for n in range(3, 11))
  • 使用包含yield的函數來生成

若是計算過程比較簡單，能夠直接把列表生成式改爲generator；可是，若是計算過程比較複雜，就只能經過包含yield的函數來構造generator。

說明： Python 3.3以前的版本中，不容許迭代函數法中包含return語句。

3. 生成器構造實例

# 使用相似列表生成式的方式構造生成器
g1 = (2*n + 1 for n in range(3, 6))

# 使用包含yield的函數構造生成器
def my_range(start, end):
    for n in range(start, end):
        yield 2*n + 1

g2 = my_range(3, 6)
print(type(g1))
print(type(g2))

輸出結果：

<class 'generator'>
<class 'generator'>

4. 生成器的執行過程與特性

生成器的執行過程：

在執行過程當中，遇到yield關鍵字就會中斷執行，下次調用則繼續從上次中斷的位置繼續執行。

生成器的特性：

  • 只有在調用時纔會生成相應的數據
  • 只記錄當前的位置
  • 只能next，不能prev

5. 生成器的調用方式

要調用生成器產生新的元素，有兩種方式：

  • 調用內置的next()方法
  • 使用循環對生成器對象進行遍歷（推薦）
  • 調用生成器對象的send()方法

實例1：使用next()方法遍歷生成器

print(next(g1))
print(next(g1))
print(next(g1))
print(next(g1))

輸出結果：

7
9
11
Traceback (most recent call last):
  File "***/generator.py", line 26, in <module>
    print(next(g1))
StopIteration
print(next(g2))
print(next(g2))
print(next(g2))
print(next(g2))

輸出結果：

7
9
11
Traceback (most recent call last):
  File "***/generator.py", line 31, in <module>
    print(next(g2))
StopIteration

可見，使用next()方法遍歷生成器時，最後是以拋出一個StopIeration異常終止。

實例2：使用循環遍歷生成器

for x in g1:
    print(x)

for x in g2:
    print(x)

兩個循環的輸出結果是同樣的：

7
9
11

可見，使用循環遍歷生成器時比較簡潔，且最後不會拋出一個StopIeration異常。所以使用循環的方式遍歷生成器的方式纔是被推薦的。

須要說明的是：若是生成器函數有返回值，要獲取該返回值的話，只能經過在一個while循環中不斷的next()，最後經過捕獲StopIteration異常

實例3：調用生成器對象的send()方法

def my_range(start, end):
    for n in range(start, end):
        ret = yield 2*n + 1
        print(ret)

g3 = my_range(3, 6)
print(g3.send(None))
print(g3.send('hello01'))
print(g3.send('hello02'))

輸出結果：

7
hello01
9
hello02
11
print(next(g3))
print(next(g3))
print(next(g3))

輸出結果：

7
None
9
None
11

結論：

  • next()會調用yield，但不給它傳值
  • send()會調用yield，也會給它傳值（該值將成爲當前yield表達式的結果值）

須要注意的是：第一次調用生成器的send()方法時，參數只能爲None，不然會拋出異常。固然也能夠在調用send()方法以前先調用一次next()方法，目的是讓生成器先進入yield表達式。

6. 生成器與列表生成式對比

既然經過列表生成式就能夠直接建立一個新的list，那麼爲何還要有生成器存在呢？

由於列表生成式是直接建立一個新的list，它會一次性地把全部數據都存放到內存中，這會存在如下幾個問題：

  • 內存容量有限，所以列表容量是有限的；
  • 當列表中的數據量很大時，會佔用大量的內存空間，若是咱們僅僅須要訪問前面有限個元素時，就會形成內存資源的極大浪費；
  • 當數據量很大時，列表生成式的返回時間會很慢；

而生成器中的元素是按照指定的算法推算出來的，只有調用時才生成相應的數據。這樣就沒必要一次性地把全部數據都生成，從而節省了大量的內存空間，這使得其生成的元素個數幾乎是沒有限制的，而且操做的返回時間也是很是快速的（僅僅是建立一個變量而已）。

咱們能夠作個試驗：對比一下生成一個1000萬個數字的列表，分別看下用列表生成式和生成器時返回結果的時間和所佔內存空間的大小：

import time
import sys

time_start = time.time()
g1 = [x for x in range(10000000)]
time_end = time.time()
print('列表生成式返回結果花費的時間： %s' % (time_end - time_start))
print('列表生成式返回結果佔用內存大小：%s' % sys.getsizeof(g1))

def my_range(start, end):
    for x in range(start, end):
        yield x

time_start = time.time()
g2 = my_range(0, 10000000)
time_end = time.time()
print('生成器返回結果花費的時間： %s' % (time_end - time_start))
print('生成器返回結果佔用內存大小：%s' % sys.getsizeof(g2))

輸出結果：

列表生成式返回結果花費的時間： 0.8215489387512207
列表生成式返回結果佔用內存大小：81528056
生成器返回結果花費的時間： 0.0
生成器返回結果佔用內存大小：88

可見，生成器返回結果的時間幾乎爲0，結果所佔內存空間的大小相對於列表生成器來講也要小的多。

4、可迭代對象（Iterable）

咱們常常在Python的文檔中看到「Iterable」這個此，它的意思是「可迭代對象」。那麼什麼是可迭代對象呢？
可直接用於for循環的對象統稱爲可迭代對象（Iterable）。

目前咱們已經知道的可迭代（可用於for循環）的數據類型有：

  • 集合數據類型：如list、tuple、dict、set、str等
  • 生成器（Generator）

可使用isinstance()來判斷一個對象是不是Iterable對象：

from collections import Iterable
print(isinstance([], Iterable))

5、迭代器（Iterator）

1. 迭代器的定義

能夠被next()函數調用並不斷返回下一個值的對象稱爲迭代器：Iterator。

很明顯上面講的生成器也是迭代器。固然，咱們可使用isinstance()來驗證一下：

from collections import Iterator
print(isinstance((x for x in range(5)), Iterator))

輸出結果爲：True

2. 對迭代器的理解

實際上，Python中的Iterator對象表示的是一個數據流，Iterator能夠被next()函數調用被不斷返回下一個數據，直到沒有數據能夠返回時拋出StopIteration異常錯誤。能夠把這個數據流看作一個有序序列，但咱們沒法提早知道這個序列的長度。同時，Iterator的計算是惰性的，只有經過next()函數時纔會計算並返回下一個數據。（此段內容來自 這裏）

生成器也是這樣的，由於生成器也是迭代器。

6、Iterable、Iterator與Generator之間的關係

  • 生成器對象既是可迭代對象，也是迭代器： 咱們已經知道，生成器不但能夠做用與for循環，還能夠被next()函數不斷調用並返回下一個值，直到最後拋出StopIteration錯誤表示沒法繼續返回下一個值了。也就是說，生成器同時知足可迭代對象和迭代器的定義；
  • 迭代器對象必定是可迭代對象，反之則不必定： 例如list、dict、str等集合數據類型是可迭代對象，但不是迭代器，可是它們能夠經過iter()函數生成一個迭代器對象。

也就是說：迭代器、生成器和可迭代對象均可以用for循環去迭代，生成器和迭代器還能夠被next()方函數調用並返回下一個值。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程