如何从列表理解而不是嵌套列表中获得平坦的结果？

Question

我有一个列表 A 和一个函数 f，它接受 A 的一项并返回一个列表。 我可以使用列表理解来转换 A 中的所有内容，例如 [f(a) for a in A]，但这会返回一个列表列表。 假设我的输入是 [a1,a2,a3]，结果是 [[b11,b12],[b21,b22],[b31,b32]]。

我怎样才能得到扁平列表[b11,b12,b21,b22,b31,b32]？ 换句话说，在 Python 中，我如何获得函数式编程语言中传统上称为 flatmap 或 .NET 中的 SelectMany 的内容？

（在实际代码中，A是目录列表，f是os.listdir。我想构建一个子目录的平面列表.)

---

_{另请参阅：如何从列表列表中制作平面列表？，了解更普遍的问题创建列表后将其展平。}

Answer 1

您可以在单个列表理解中进行嵌套迭代：

[filename for path in dirs for filename in os.listdir(path)]

这相当于（至少在功能上）：

filenames = []
for path in dirs:
    for filename in os.listdir(path):
        filenames.append(filename)

Answer 2

>>> from functools import reduce  # not needed on Python 2
>>> list_of_lists = [[1, 2],[3, 4, 5], [6]]
>>> reduce(list.__add__, list_of_lists)
[1, 2, 3, 4, 5, 6]

itertools 解决方案效率更高，但这感觉非常Pythonic。

Answer 3

您可以在 itertools 食谱中找到一个很好的答案：

import itertools

def flatten(list_of_lists):
    return list(itertools.chain.from_iterable(list_of_lists))

Answer 4

提出的问题是flatmap。 提出了一些实现，但它们可能不需要创建中间列表。 这是一种基于迭代器的实现。

def flatmap(func, *iterable):
    return itertools.chain.from_iterable(map(func, *iterable))

In [148]: list(flatmap(os.listdir, ['c:/mfg','c:/Intel']))
Out[148]: ['SPEC.pdf', 'W7ADD64EN006.cdr', 'W7ADD64EN006.pdf', 'ExtremeGraphics', 'Logs']

在 Python 2.x 中，使用 itertools.map 代替 map。

Answer 5

你可以直接做：

subs = []
for d in dirs:
    subs.extend(os.listdir(d))

Answer 6

您可以使用普通的加法运算符连接列表：

>>> [1, 2] + [3, 4]
[1, 2, 3, 4]

内置函数 sum 会将数字按顺序相加，并且可以选择从特定值开始：

>>> sum(xrange(10), 100)
145

将以上内容组合起来以展平列表列表：

>>> sum([[1, 2], [3, 4]], [])
[1, 2, 3, 4]

您现在可以定义您的平面图：

>>> def flatmap(f, seq):
...   return sum([f(s) for s in seq], [])
... 
>>> flatmap(range, [1,2,3])
[0, 0, 1, 0, 1, 2]

编辑：我刚刚在另一个答案，我想Python将使用此解决方案不必要地构建和垃圾收集大量较小的列表是正确的。 因此，关于它最好的一点是，如果您习惯于函数式编程，那么它非常简单和简洁:-)

Answer 7

subs = []
map(subs.extend, (os.listdir(d) for d in dirs))

（但蚂蚁的答案更好；为他+1）

Answer 8

import itertools
x=[['b11','b12'],['b21','b22'],['b31']]
y=list(itertools.chain(*x))
print y

itertools 将在 python2.3 及更高版本上运行

Answer 9

您可以尝试 itertools.chain()，如下所示：

import itertools
import os
dirs = ["c:\\usr", "c:\\temp"]
subs = list(itertools.chain(*[os.listdir(d) for d in dirs]))
print subs

itertools.chain() 返回一个迭代器，因此传递给 list()。

Answer 10

这是最简单的方法：

def flatMap(array):
  return reduce(lambda a,b: a+b, array) 

“a+b”指的是两个列表的串联

Answer 11

您可以使用 pyxtension：

from pyxtension.streams import stream
stream([ [1,2,3], [4,5], [], [6] ]).flatMap() == range(7)

Answer 12

谷歌给我带来了下一个解决方案：

def flatten(l):
   if isinstance(l,list):
      return sum(map(flatten,l))
   else:
      return l

Answer 13

我在寻找flatmap并首先发现了这个问题。 flatmap 基本上是原始问题要求的概括。 如果您正在寻找一种为可求和集合（例如列表）定义 flatmap 的简洁方法，您可以使用

sum(map(f,xs),[])

它，它只比直接编写长一点

flatmap(f,xs)

，但一开始可能不太清晰。

最明智的解决方案是将 Flatmap 作为编程语言中的基本函数，但只要它不是，您仍然可以使用更好或更具体的名称来定义它：

# `function` must turn the element type of `xs` into a summable type.
# `function` must be defined for arguments constructed without parameters.
def aggregate(function, xs):
    return sum( map(function, xs), type(function( type(xs)() ))() )

# or only for lists
aggregate_list = lambda f,xs: sum(map(f,xs),[])

不幸的是，字符串不可求和，这对他们不起作用。
你可以做

assert( aggregate_list( lambda x: x * [x], [2,3,4] ) == [2,2,3,3,3,4,4,4,4] )

但你不能做

def get_index_in_alphabet(character):
    return (ord(character) & ~0x20) - ord('A')

assert(aggregate( lambda x: get_index_in_alphabet(x) * x, "abcd") == "bccddd")

对于字符串，你需要使用

aggregate_string = lambda f,s: "".join(map(f,s))  # looks almost like sum(map(f,s),"")

assert( aggregate_string( lambda x: get_index_in_alphabet(x) * x, "abcd" ) == "bccddd" )

它显然是一团糟，需要不同的函数名称，甚至不同类型的语法。 希望 Python 的类型系统将来能够得到改进。

Answer 14

您还可以使用 numpy 来使用 flatten 函数：

import numpy as np

matrix = [[i+k for i in range(10)] for k in range(10)]
matrix_flat = np.array(arr).flatten()

numpy 文档 展平

Answer 15

为什么 flatten 和 flat_map 函数不适用于任何使用生成器的可迭代对象？

def flatten(iters):
    for it in iters:
        for elem in it:
            yield elem

def flat_map(fn, it):
    return flatten(map(fn, it))

用法非常简单：

for e in flat_map(range, [1, 2, 3]):
    print(e, end=" ")
# Output: 0 0 1 0 1 2

作为一个有趣的琐事，您也可以以递归方式编写展平。 留给有兴趣的读者分析吧！

def flatten(it):
    try:
        yield from next(it)
        yield from flatten(it)
    except StopIteration:
        pass

Answer 16

递归可以有效地展平任何嵌套列表结构。 下面是示例代码片段：

lst = [1,2,4, [3,2,5,6], [1,5,6,[9,20,23,45]]]

def flatten_list(l):
  flat_data = []
  for i in l:
    if type(i) != list:    # or you can use:  if isinstance(i, list):
      flat_data.append(i)
    else:
      flat_data.extend(flatten_list(i))
  return flat_data

print(flatten_list(lst))

在此代码中，flatten_list 函数递归遍历嵌套列表，将非列表元素附加到 flat_data 列表。 当遇到嵌套列表时，它会递归地调用自身，直到所有元素都被展平。 此方法可确保有效处理列表中的任何级别的嵌套，从而生成单个展平列表作为输出。

Answer 17

递归可以有效地展平任何嵌套列表结构。 下面是示例代码片段：

lst = [1,2,4, [3,2,5,6], [1,5,6,[9,20,23,45]]]

def flatten_list(l):
  flat_data = []
  for i in l:
    if type(i) != list:    # or you can use:  if isinstance(i, list):
      flat_data.append(i)
    else:
      flat_data.extend(flatten_list(i))
  return flat_data

print(flatten_list(lst))

在此代码中，flatten_list 函数递归遍历嵌套列表，将非列表元素附加到 flat_data 列表。 当遇到嵌套列表时，它会递归地调用自身，直到所有元素都被展平。

Answer 18

If listA=[list1,list2,list3]
flattened_list=reduce(lambda x,y:x+y,listA)

这样就可以了。