Python 中的展開列表

一個列表被認為是 Python 編程語言中最靈活的數據結構之一。另一方面，通常稱為列表的二維列表或 2D 列表是列表的對象，其中每個元素本身就是列表。例如:[[19，18，17]，[16，15，14]，[13，12，11]]。

展開列表是通過取消嵌套列表中保存的每個列表元素，將二維列錶轉換為一維列表的過程，也就是說，將[[9，8，7]，[6，5，4]，[3，2，1]]轉換為[9，8，7，6，5，4，3，2，1]。

我們可以藉助嵌套的對循環、遞歸、列表推導、核心函數執行展開過程，或者在 Python 中根據嵌套列表的深度和規律性導入庫或包。

在本教程中，我們將研究各種方法，以便使用 Python 編程語言來展開嵌套列表。但是在開始之前，讓我們了解嵌套列表的類型。

我們知道， Python 是一種弱類型的編程語言。因此，我們會遇到兩種類型的列表。這些列表或嵌套列表如下:

1. 常規列表
2. 不規則列表

常規列表

列表常規列表中的每個項目都被稱為子列表，從而觀察元素類型的一致性。例如:[[9，8，7]，[6，5，4]，[3，2，1]]是常規列表，因為[9，8，7]，[6，5，4]，[3，2，1]是列表類型。

不定期列表

不規則列表中的每一項都被稱為子列表或非列表元素(例如，字符串或整數)。因此，在元素類型方面存在不規則性。例如:[[9，8，7]，[6，5]，4，3]是不規則的列表，因為[9，8，7]和[6，5]是列表類型，而 4 和 3 是 int 類型。

使用嵌套的對列表列表進行展開以獲得循環的幫助被認為是獲得展開列表的強力方法。我們可以通過從二維列表中選擇每個項目並將其排列在一維列表中來執行此方法。

讓我們考慮下面的例子，它既適用於規則列表，也適用於不規則列表。

示例:

# defining the function
def flattenlist(_2dlist):
    # defining an empty list
    flatlist = []
    # Iterating through the outer list
    for item in _2dlist:
        if type(item) is list:
            # If the item is of the list type, iterating through the sub-list
            for element in item:
                flatlist.append(element)
        else:
            flatlist.append(item)
    return flatlist

# defining the nested list
nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]]
print('Genuine List:', nestedlist)
print('Converted Flat List:', flattenlist(nestedlist))

輸出:

Genuine List: [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]]
Converted Flat List: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

說明:

在上面的例子中，我們定義了一個函數為flanlist，它接受一個參數為 _2dlist 。然後，我們使用循環來迭代嵌套列表的元素，並將它們追加以生成一個扁平列表。然後，我們定義了嵌套列表並實現了flat list函數。因此，嵌套列表已成功轉換為展開列表。

**### 使用列表推導展開嵌套列表

在列表推導的幫助下展開列表被認為是一種根據二維現有列表獲得展開列表的優雅方法。然而，這種方法提供了一種不太直觀的解決方案。

讓我們考慮下面的例子。

示例:

# defining the nested list
nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90]]
# list comprehension
flatlist = [element for sub_list in nestedlist for element in sub_list]
print('Genuine list:', nestedlist)
print('Converted list:', flatlist)

輸出:

Genuine list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]]
Converted list: [10, 20, 30, 40, 50, 60, 70, 80, 90]

說明:

在上面的例子中，我們定義了嵌套列表和列表推導。然後，我們為用戶打印了它們。因此，嵌套列表已成功轉換為展開列表。

我們也可以使用遞歸方法來展開二維列表。讓我們考慮以下實現遞歸方法的示例，以便展開列表列表。這種實現適用於常規和非常規列表。

示例:

# defining a function
def flattenlist(nestedlist):
    if len(nestedlist) == 0:
        return nestedlist
    if isinstance(nestedlist[0], list):
        return flattenlist(nestedlist[0]) + flattenlist(nestedlist[1:])
    return nestedlist[:1] + flattenlist(nestedlist[1:])

print(flattenlist([[10, 20, 30, 40], [50, 60, 70], [80, 90], 100]))

輸出:

[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

說明:

在上面的例子中，我們定義了一個函數，並使用了if語句來聲明嵌套列表的長度是否等於零，然後返回嵌套列表。

**如果第零個索引上的數據元素是列表的一個實例，那麼列表索引將再次進入函數，並添加到列表的下一個索引中，以此類推。否則函數將返回元素等等。最後，我們定義了嵌套列表並執行了函數。結果，列表列表遞歸地變平了。

我們還可以利用一些 Python 編程語言庫來展開列表。這些庫的實現描述如下:

使用功能工具和操作員庫展開列表列表

運算符庫提供了 iconcat() 函數來執行基本操作，如連接。我們可以將此函數從左到右累積應用於嵌套列表的數據元素，從而將嵌套列表簡化為扁平列表。

讓我們考慮下面的例子來理解它的實現。

示例:

# importing the required libraries
import operator
import functools
regularlist = []

# Converting the list of lists into a flattened one.
def convo(nestedlist):
    for element in nestedlist:
        if type(element) is list:
            regularlist.append(element)
        else:
            regularlist.append([element])
    return regularlist

twoDlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100], 110]
regular2Dlist = convo(twoDlist)
print('Given List:', twoDlist)
print('Converted list:', functools.reduce(operator.iconcat, regular2Dlist, []))

輸出:

Given List: [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100], 110]
Converted list: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110]

說明:

在上面的例子中，我們已經導入了功能工具庫和操作符庫。然後，我們將一個空列表定義為常規列表。然後，我們定義了一個函數卷積來將列錶轉換為扁平列表。在這個函數中，我們將用於循環，其中嵌套列表中的元素被追加到我們之前定義的空列表中。稍後，我們已經定義了嵌套列表並執行了函數。因此，列表列表被成功轉換為展開列表。

使用 itertools 庫展開列表列表

itertools 庫提供了鏈()功能，允許我們理想地將嵌套列錶轉換為單個扁平列表。該函數通過以串行方式通過作為參數傳遞的 iterable 對連續序列進行迭代，將它們視為單個序列。

讓我們考慮下面的例子:

示例:

# importing the itertools library
import itertools

# defining the nested list
nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]]
flattenlist = list(itertools.chain(*nestedlist))

print('The nested list:', nestedlist)
print('The flattened list:', flattenlist

輸出:

The nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90, 100]]
The flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

說明:

在上面的例子中，我們已經導入了 itertools 庫並生成了一個嵌套列表。然後，我們使用鏈()函數將給定的嵌套列錶轉換為扁平列表。最後，我們將結果返回給用戶。結果，列表列表被成功展開。

使用 NumPy 庫展開列表列表

NumPy 庫提供各種日常操作，包括按列或按行連接二維常規數組。我們將使用稱為平面的屬性，以便在數組上獲得一維迭代器來征服目標。讓我們考慮下面的例子來理解 concatenate 函數和 flat 屬性的使用。

示例:

# importing the library
import numpy

# defining the nested list
nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90]]

# using the concatenate function along with the flat attribute
flattenlist = list(numpy.concatenate(nestedlist).flat)

print('The Nested list:', nestedlist)
print('The Flattened list:', flattenlist)

輸出:

The Nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]]
The Flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90]

說明:

在上面的例子中，我們已經導入了 numpy 庫並定義了一個嵌套列表。然後，我們使用了 numpy 庫的連接功能及其扁平屬性來展開嵌套列表的元素，並將它們連接到一個新的扁平列表。最後，我們為用戶打印了結果。因此，列表列表被成功展開。

我們還可以利用 Python 編程語言提供的一些核心功能來執行展開任務。

使用求和功能展開列表列表

我們可以考慮對內部列表求和，作為解決問題的另一種方法。我們將兩個參數傳遞給 sum 函數:第一個參數是可迭代，這是一個嵌套列表，第二個參數是 start ，這是一個空列表，用於以下情況，作為內部子列表的數據元素將添加到的初始平面列表。

我們可以說這種方法非常方便，因為我們不需要導入任何東西。但是，當嵌套列表中存在大量子列表時，它比 itertools() 和 chain() 函數慢。

讓我們考慮下面的例子:

示例:

# defining a nested list
nestedlist = [[10, 20, 30, 40], [50, 60, 70], [80, 90]]

# using the sum function
flattenlist = sum(nestedlist, [])

print('The Nested list:', nestedlist)
print('The Flattened list:', flattenlist)

輸出:

The Nested list: [[10, 20, 30, 40], [50, 60, 70], [80, 90]]
The Flattened list: [10, 20, 30, 40, 50, 60, 70, 80, 90]

說明:

在上面的例子中，我們已經定義了嵌套列表。然後，我們使用 sum() 函數，將嵌套列表展開為一維列表，並為用戶打印結果列表。結果，我們成功地將列表列錶轉換為平面列表。

使用 Lambda 關鍵字展開列表列表

我們可以使用關鍵字λ定義一個匿名函數。我們可以將規則/不規則列表作為參數傳遞給這個匿名函數。表達式的計算是為了得到一個平面的一維列表。

讓我們考慮下面的例子:

示例:

# Defining the nested list
nestedlist = [[10, 20, 30], [30, 50, 60], [40, 60, 70], 70]

# Using lambda parameters: expression
flattenlist = lambda nestedlist:[item for element in nestedlist for item in flattenlist(element)] if type(nestedlist) is list else [nestedlist]

print("The Nested list:", nestedlist)
print("The Flattened List:", flattenlist(nestedlist))

輸出:

The Nested list: [[10, 20, 30], [30, 50, 60], [40, 60, 70], 70]
The Flattened List: [10, 20, 30, 30, 50, 60, 40, 60, 70, 70]

說明:

在上面的例子中，我們定義了一個嵌套列表。然後，我們使用了【λ】關鍵字以及定義列表推導表達式的參數。然後，我們為用戶打印了它們。因此，我們成功地將二維不規則列錶轉換為扁平列表。