在Python中扁平化列表|极客笔记

在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]。

我们可以通过使用嵌套的 for 循环、递归、列表理解、核心函数来执行扁平化的过程，也可以在Python中根据嵌套列表的深度和规律性导入库或包。

在本教程中，我们将使用Python编程语言来展示各种方法，以便扁平化嵌套列表。但在开始之前，让我们先了解嵌套列表的类型。

嵌套列表有哪些类型

正如我们所知，Python是一种弱类型编程语言。因此，我们可以遇到两种类型的列表：列表的列表。这些列表的列表或嵌套列表如下：

常规列表的列表
不规则的列表的列表

常规列表的列表

常规列表的列表中的每个项目都被称为子列表，从而观察到元素类型的统一性。例如：[[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是整数类型。

使用嵌套for循环扁平化列表的方法

使用嵌套 for 循环的帮助扁平化列表的方法被认为是一种蛮力方法来获得一个平坦的列表。我们可以通过从二维列表中选择每个项目并将其排列在一维列表中来执行此方法。

让我们来看一个适用于常规列表和不规则列表的列表的示例。

示例：

# 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]

解释:

在上面的示例中，我们定义了一个函数，名为 flattenlist ，接受一个名为 _2dlist 的参数。然后我们使用 for 循环迭代嵌套列表的元素，并将它们添加到一个生成的扁平列表中。然后我们定义了嵌套列表并实现了 flattenlist 函数。结果，嵌套列表成功转化为扁平列表。

使用列表推导来扁平化嵌套列表

使用列表推导来扁平化列表的列表可以说是一种优雅的方法，它可以根据现有的二维列表获得一个扁平的列表。然而，这种方法提供了一个不太直观的解决方案。

让我们看以下示例。

示例:

# 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的库

我们还可以利用一些Python编程语言的库来展开列表。这些库的实现如下所述：

使用functools和operator库展开列表

operator 库提供了 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]

说明：

在上面的示例中，我们导入了 functools 库和 operator 库。然后，我们将一个空列表定义为 regularlist 。然后，我们定义一个名为 convo 的函数来将列表的列表转换为扁平化的列表。在这个函数中，我们使用了 for 循环，将嵌套列表中的元素添加到之前定义的空列表中。然后，我们定义了嵌套列表并执行了这个函数。结果，列表的列表成功地转换为了扁平化的列表。

使用itertools库扁平化列表的方法

itertools 库提供了 chain() 函数，它允许我们将嵌套列表理想地转换为单个扁平化的列表。这个函数通过迭代传递的可迭代对象中的连续系列，以连续方式迭代它们。

让我们考虑以下示例：

示例：

# 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 库并生成了一个嵌套列表。然后我们使用 chain() 函数将给定的嵌套列表转换为扁平化的列表。最后，我们将结果返回给用户。结果是，列表的列表已成功扁平化。

使用NumPy库扁平化列表的列表

NumPy 库提供各种日常操作，包括按列或按行连接二维正规数组。我们将使用名为 flat 的属性来获取数组上的一维迭代器以实现目标。让我们考虑以下示例以理解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 库的 concatenate 函数以及它的 flat 属性来将嵌套列表的元素展平并将它们连接成一个新的展平列表。最后，我们将结果打印出来供用户查看。因此，嵌套列表成功展平。

利用核心函数

我们还可以利用Python编程语言提供的一些核心函数来执行展平任务。

使用sum函数展平列表

我们可以将对内部列表进行求和视为解决问题的另一种方法。我们向 sum 函数传递两个参数：第一个参数是 iterable ，即嵌套列表，第二个参数是 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关键字展开列表的列表

我们可以使用关键字 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]

解释:

在上面的示例中，我们定义了一个嵌套列表。然后我们使用了 lambda关键字，以及定义了一个表达式用于列表推导。然后我们将它们打印给用户。结果是，我们成功地将二维不规则列表转换为扁平列表。

在Python中扁平化列表