Python列表解析和生成器表達式的結構是什么

今天小編給大家分享一下Python列表解析和生成器表達式的結構是什么的相關知識點，內容詳細，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。

列表解析與生成器表達式

生成器表達式是生成容器的一種簡潔方式。最常見的是，你會聽到列表解析，但也存在集合解析和字典解析。但是，術語上的差異有些重要：如果你實際上是在制作列表，那么它只是一個列表解析。

生成器表達式用括號括起來( )，而列表解析用方括號括起來[ ]。集合解析用花括號括起來{ }。除了這些差異之外，所有三種情況的語法都是相同的！

（字典解析還有更多內容，我們稍后會討論。）

生成器表達式與生成器有關，我們將在后面的部分深入探討。現在，我們只要使用生成器表達式的官方定義就足夠了：

生成器表達式 - 返回迭代器的表達式。

生成器表達式的結構

生成器表達式（或列表/集合戶外組）有點像一個被翻轉的for循環。

舉一個簡單的例子，讓我們回顧上一篇文章中的一個例子，我們將華氏溫度列表轉換為攝氏溫度。我會稍微調整一下，所以數字將存儲在另一個列表中，而不是直接打印。

temps_f = [67.0, 72.5, 71.3, 78.4, 62.1, 80.6]
temps_c = []

def f_to_c(temp):
    return round((temp - 32) / 1.8, 1)

for c in map(f_to_c, temps_f):
    temps_c.append(c)

print(temps_c)

信不信由你，列表解析將使整個程序減少到三行！我們一次簡化為一部分，好讓你可以理解我的意思。

讓我們從用列表解析替換 for 循環開始......

temps_f = [67.0, 72.5, 71.3, 78.4, 62.1, 80.6]

def f_to_c(temp):
    return round((temp - 32) / 1.8, 1)

temps_c = [f_to_c(temp) for temp in temps_f]

print(temps_c)

重要的代碼行是temps_c = [f_to_c(temp) for temp in temps_f]. 這表現得非常像map()。temp對于列表中的每個元素temps_f，我們應用該函數f_to_c()。

現在，如果我在其他地方需要f_to_c()函數，我就停在這里結束了。但是，如果這是我需要華氏到攝氏度轉換邏輯的唯一地方，我可以完全不使用該函數，并將邏輯代碼直接移動到解析中：

temps_f = [67.0, 72.5, 71.3, 78.4, 62.1, 80.6]
temps_c = [round((temp-32) / 1.8, 1) for temp in temps_f]
print(temps_c)

我跟你說了什么？三行！是不是只有三行代碼！

根據我獲得的數據，我甚至可以進一步減少。讓我們用另一個例子來看看這個。

想象一下，你有一個程序在一行上接收一堆整數，用空格分隔，例如5 4 1 9 5 7 5。 你想找到所有這些整數的總和。（為簡單起見，假設你沒有輸入錯誤的風險。）

讓我們先以一種顯而易見的方式編寫它，而無需列表解析。

user_input = input()
values = user_input.split(' ')

total = 0

for v in values:
    n = int(v)
    total += n

print(total)

很明顯，對吧？我們將用戶輸入作為字符串獲取，然后將該字符串以空格拆分列表以獲取各個數字。我們創建一個變量來存儲總數，然后使用循環遍歷每個值，將其轉換為整數，然后將其添加到總數中。現在我們有了代碼邏輯，讓我們對其進行簡化和優化。

讓我們首先在這里簡化一些顯而易見的代碼。我們之前已經介紹了所有這些概念，所以看看你是否能發現我改進的地方。

values = input().split(' ')
total = 0

for v in values:
    total += int(v)

print(total)

除非我們使用列表解析，否則我們不能比這更簡單，所以現在就開始吧！

values = input().split(' ')
total = sum(int(v) for v in values)
print(total)

這里的生成器表達式是(int(v) for v in values)。v對應列表中的每個值values，我們將其轉換為整數 ( int(v))。

請注意我是如何使用該sum()函數的，將生成器表達式直接傳遞給它。由于表達式直接作為唯一參數傳遞，因此我不需要在它周圍加上額外的括號。

現在，如果我不需要values其他任何列表，我實際上可以將該邏輯直接移動到生成器表達式中！

total = sum(int(v) for v in input().split(' '))
print(total)

像做餡餅一樣容易，對吧？

嵌套列表解析

如果相反，我們想要輸入的每個數字的平方和呢？事實上，有兩種方法可以做到這一點。簡單做法是這樣：

total = sum(int(v)**int(v) for v in input().split(' '))
print(total)

這行得通，但不知何故，它只是感覺不對，不是嗎？我們要轉換兩次v為整數。

我們可以通過將列表解析嵌套到我們的生成器表達式中來解決這個問題！

total = sum(n**2 for n in [int(v) for v in input().split(' ')])

列表解析和生成器表達式從內部到外部進行解析。最里面的表達式 ,int(v) for v in input().split(' ')首先運行，并且封閉的方括號[ ]將其轉換為列表（可迭代）。

接下來，n**2 for n in [LIST]運行外部表達式，[LIST]就是我們剛才生成的列表。

這種嵌套不是很容易理解，也不直觀。盡量少用它。當我需要嵌套時，我將每個列表理解寫在單獨的行上并將其存儲...

the_list = [int(v) for v in input().split(' ')]
total = sum(n**2 for n in the_list)
print(total)

...測試一下，然后通過復制和粘貼開始嵌套。

生成器表達式中的條件

如果我們只想要列表中奇數的總和怎么辦？生成器表達式和列表解析也可以做到這一點。

我們將在此示例中使用嵌套，但我們將首先從非嵌套版本開始，為了使新邏輯更易于查看。

the_list = [int(v) for v in input().split(' ')]
total = sum(n**2 for n in the_list if n%2==0)
print(total)

新部分在第二行。在生成器表達式的末尾，我添加了if n%2==0. 你可能認識模運算符 ( %)，它為我們提供了除法的余數。任何偶數都可以被2整除，這意味著它沒有余數。因此，n%2==0僅適用于偶數。

將條件放在語句之后而不是之前，感覺有點奇怪。理解它的最簡單方法是和沒有生成器表達式的相同代碼邏輯做對比......

output = []
for n in the_list:
    if n%2==0:
        output.append(n**2)

基本上，要將其轉換為生成器表達式，你只需知道append()，從這兒開始......

n**2
for n in the_list:
    if n%2==0:

然后從for和if語句中刪除冒號 ( :)、換行符縮進...

n**2 for n in the_list if n%2==0

多個迭代對象

我們還可以使用生成器表達式和列表解析一次循環遍歷多個可迭代對象，其方式與嵌套循環相同。

考慮以下邏輯：

num_a = [1, 2, 3, 4, 5]
num_b = [6, 7, 8, 9, 10]
output = []

for a in num_a:
    for b in num_b:
        output.append(a*b)

我們也可以按照我剛才給出的相同步驟將其轉換為列表解析！我們把append()的參數放在前面...

a*b
for a in num_a:
    for b in num_b:

...然后我們將其余部分折疊成一行，刪除冒號。

a*b for a in num_a for b in num_b

最后，將其包裹在方括號中，并將其復制給變量output輸出。

output = [a*b for a in num_a for b in num_b]

集合解析

正如我在文章開頭提到的，就像你可以使用包含在方括號[ ]中的生成器表達式來創建列表一樣，你也可以使用花括號{ }來創建集合。

例如，讓我們生成通過100 除以小于 100 的奇數得到的所有余數組成的集合。通過使用集合，我們確保沒有重復項，使結果更容易理解。

odd_remainders = {100%n for n in range(1,100,2)}
print(odd_remainders)

運行該代碼給我們...

{0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 25, 26, 27, 29, 30, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49}

這里真的沒有什么特別的地方。集合解析的工作方式與列表解析相同，只是創建了不同的容器。

字典解析

字典解析遵循與其他形式的生成器表達式幾乎相同的結構，但有一個區別：冒號。

如果你還記得，當你創建集合或字典時，你使用花括號{ }。唯一的區別是，在字典中，你使用冒號:來分隔鍵值對，這是在集合中不會執行的操作。同樣的原則在這里也適用。

例如，如果我們想創建一個字典，將 1 到 100 之間的整數存儲為鍵，并將該數字的平方作為值...

squares = {n : n**2 for n in range(1,101)}
print(squares)

這就是字典解析！除了冒號之外:，其他所有內容都與任何其他生成器表達式相同。

風險

對所有情況都使用列表解析或生成器表達式可能非常誘人。它們相當容易上癮，部分原因是寫出來時看起來非常高端優雅。強大的單行代碼讓程序員非常興奮——我們真的很喜歡優雅地地處理我們的代碼。

但是，我必須提醒你不要過分追求優雅。記住The Zend Of Python，這里有一些與此主題相關的部分：

美麗總比丑陋好。
...
簡單勝于復雜。
復雜勝于復雜。
平面優于嵌套。
稀疏比密集好。
可讀性很重要。
...

列表解析可能很優雅，但如果使用不當，它們也可能成為密集的、垃圾的邏輯片段。

1.代碼變得難以閱讀

我從互聯網上的一項調查中借用了這個例子

primary = [ c for m in status['members'] if m['stateStr'] == 'PRIMARY' for c in rs_config['members'] if m['name'] == c['host'] ]
secondary = [ c for m in status['members'] if m['stateStr'] == 'SECONDARY' for c in rs_config['members'] if m['name'] == c['host'] ]
hidden = [ m for m in rs_config['members'] if m['hidden'] ]

你能說出這段代碼的意思？如果你閱讀一會，你可能可以，但你為什么要閱讀？代碼一清二楚。（在調查中，這被評為最不可讀的示例。）當然，你可以添加注釋來解釋正在執行的邏輯 - 事實上，他們在原始示例中做了 - 但任何時候你需要注釋來解釋代碼正在做什么，這幾乎可以肯定太復雜了。

列表解析和生成器表達式固然很強大，但如果大量使用會像剛剛那樣變得難以閱讀。

不一定非得像剛剛那樣做。只需將列表理解拆分為多行，你就可以重新獲得很多可讀性，其結構與傳統循環類似。

primary = [
    c
    for m in status['members']
        if m['stateStr'] == 'PRIMARY'
    for c in rs_config['members']
        if m['name'] == c['host']
    ]

secondary = [
    c
    for m in status['members']
        if m['stateStr'] == 'SECONDARY'
    for c in rs_config['members']
        if m['name'] == c['host']
    ]

hidden = [
    m
    for m in rs_config['members']
        if m['hidden']
    ]

請注意，這并不能完全證明上述說法是正確的。我仍然會使用傳統的循環而不是前面的示例，只是因為它們更易于閱讀和維護。

如果你仍然不相信這是 Python 的一個容易被濫用的特性？我的有一個朋友分享他遇到的這個真實案例。我們根本不知道它做了什么。

cropids = [self.roidb[inds[i]]['chip_order'][
               self.crop_idx[inds[i]] % len(self.roidb[inds[i]]['chip_order'])] for i in
           range(cur_from, cur_to)]

光是看著，我的可能都會有點煩躁了。

2.它們不會替換循環

看看以下情況。（此代碼是虛構的，僅供參考。）

some_list = getTheDataFromWhereever()
[API.download().process(foo) for foo in some_list]

對于未經訓練的人來說，這看起來沒啥問題，但請注意請仔細看砍......數據some_list正在被直接修改（變異），但結果沒有被存儲。這是列表解析甚至生成器表達式被濫用來代替循環的情況。它使閱讀變得困難，更不用說調試了。

無論你想使用生成器表達式來變得優雅，這都是你應該堅持使用循環的一種情況：

some_list = getTheDataFromWhereever()
for foo in some_list:
    API.download().process(foo)

3.它們很難調試

想一想列表解析的本質：你將所有內容打包成一個巨大的語句。這樣做的好處是你消除了一堆中間步驟。缺點也是……你消除了一堆中間步驟。

考慮調試一個典型的循環。你可以單步執行它，一次迭代，使用調試器隨時觀察每個變量的狀態。你還可以使用錯誤處理來處理異常的邊緣情況。

相比之下，這些都不適用于生成器表達式或列表解析。一切要么有效，要么無效！你可以嘗試解析錯誤和輸出以找出你做錯了什么，但我可以向你保證，這是一種令人困惑的體驗。

你可以通過避免在你的第一個代碼版本中使用列表解析來避免這種瘋狂！使用傳統的循環和迭代器工具以顯而易見的方式編寫邏輯。一旦你知道它有效，那么并且只有在那時你才應該將邏輯折疊到生成器表達式中，并且只有在你可以這樣做而不避免錯誤處理的情況下。

這聽起來像是很多額外的工作，但我在平常的代碼編寫中中遵循了這個確切的模式。我對生成器表達式的理解通常是我對抗經驗不足的競爭對手的主要優勢，但我總是先編寫標準循環：我不能把浪費時間在調試生成器表達式中錯誤邏輯上。

以上就是“Python列表解析和生成器表達式的結構是什么”這篇文章的所有內容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學習更多的知識，請關注億速云行業資訊頻道。