Tôi tự hỏi liệu có một phím tắt để tạo một danh sách đơn giản ra khỏi danh sách các danh sách trong Python.

Tôi có thể làm điều đó trong một forvòng lặp, nhưng có lẽ có một "lớp lót" thú vị? Tôi đã thử nó với reduce(), nhưng tôi nhận được một lỗi.

Mã

l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
reduce(lambda x, y: x.extend(y), l)

Thông báo lỗi

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in <lambda>
AttributeError: 'NoneType' object has no attribute 'extend'

Đưa ra một danh sách các danh sách l,

flat_list = [item for sublist in l for item in sublist]

nghĩa là:

flat_list = []
for sublist in l:
    for item in sublist:
        flat_list.append(item)

nhanh hơn các phím tắt được đăng cho đến nay. ( llà danh sách để làm phẳng.)

Đây là chức năng tương ứng:

flatten = lambda l: [item for sublist in l for item in sublist]

Để làm bằng chứng, bạn có thể sử dụng timeitmô-đun trong thư viện chuẩn:

$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' '[item for sublist in l for item in sublist]'
10000 loops, best of 3: 143 usec per loop
$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'sum(l, [])'
1000 loops, best of 3: 969 usec per loop
$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'reduce(lambda x,y: x+y,l)'
1000 loops, best of 3: 1.1 msec per loop

Giải thích: các phím tắt dựa trên +(bao gồm cả việc sử dụng ngụ ý sum) là cần thiết, O(L**2)khi có danh sách con L - vì danh sách kết quả trung gian tiếp tục dài hơn, ở mỗi bước, một đối tượng danh sách kết quả trung gian mới được phân bổ và tất cả các mục trong kết quả trung gian trước đó phải được sao chép lại (cũng như một vài kết quả mới được thêm vào cuối). Vì vậy, để đơn giản và không mất tính tổng quát thực tế, giả sử bạn có danh sách con L của các mục I mỗi mục: các mục I đầu tiên được sao chép qua lại L-1 lần, lần thứ hai tôi ghi L-2 lần, v.v. tổng số bản sao là I lần tổng của x cho x từ 1 đến L bị loại trừ, nghĩa là , I * (L**2)/2.

Việc hiểu danh sách chỉ tạo một danh sách, một lần và sao chép từng mục qua (từ nơi cư trú ban đầu của nó sang danh sách kết quả) cũng chính xác một lần.

Bạn có thể sử dụng itertools.chain():

import itertools
list2d = [[1,2,3], [4,5,6], [7], [8,9]]
merged = list(itertools.chain(*list2d))

Hoặc bạn có thể sử dụng itertools.chain.from_iterable()mà không yêu cầu giải nén danh sách với *toán tử :

import itertools
list2d = [[1,2,3], [4,5,6], [7], [8,9]]
merged = list(itertools.chain.from_iterable(list2d))

Lưu ý từ tác giả : Điều này là không hiệu quả. Nhưng vui, bởi vì đơn sắc là tuyệt vời. Nó không thích hợp để sản xuất mã Python.

>>> sum(l, [])
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Điều này chỉ tính tổng các phần tử của iterable được truyền trong đối số thứ nhất, coi đối số thứ hai là giá trị ban đầu của tổng (nếu không được đưa ra, 0 được sử dụng thay thế và trường hợp này sẽ gây ra lỗi cho bạn).

Bởi vì bạn đang tổng hợp các danh sách lồng nhau, bạn thực sự nhận được [1,3]+[2,4]kết quả là sum([[1,3],[2,4]],[]), tương đương với[1,3,2,4] .

Lưu ý rằng chỉ hoạt động trên danh sách danh sách. Đối với danh sách danh sách các danh sách, bạn sẽ cần một giải pháp khác.

Tôi đã thử nghiệm hầu hết các giải pháp được đề xuất với perfplot (một dự án thú cưng của tôi, về cơ bản là bao bọc xung quanh timeit), và tìm thấy

functools.reduce(operator.iconcat, a, [])

là giải pháp nhanh nhất, cả khi nhiều danh sách nhỏ và một vài danh sách dài được nối với nhau. ( operator.iaddcũng nhanh không kém.)

Mã để tái tạo cốt truyện:

import functools
import itertools
import numpy
import operator
import perfplot


def forfor(a):
    return [item for sublist in a for item in sublist]


def sum_brackets(a):
    return sum(a, [])


def functools_reduce(a):
    return functools.reduce(operator.concat, a)


def functools_reduce_iconcat(a):
    return functools.reduce(operator.iconcat, a, [])


def itertools_chain(a):
    return list(itertools.chain.from_iterable(a))


def numpy_flat(a):
    return list(numpy.array(a).flat)


def numpy_concatenate(a):
    return list(numpy.concatenate(a))


perfplot.show(
    setup=lambda n: [list(range(10))] * n,
    # setup=lambda n: [list(range(n))] * 10,
    kernels=[
        forfor,
        sum_brackets,
        functools_reduce,
        functools_reduce_iconcat,
        itertools_chain,
        numpy_flat,
        numpy_concatenate,
    ],
    n_range=[2 ** k for k in range(16)],
    xlabel="num lists (of length 10)",
    # xlabel="len lists (10 lists total)"
)

from functools import reduce #python 3

>>> l = [[1,2,3],[4,5,6], [7], [8,9]]
>>> reduce(lambda x,y: x+y,l)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Các extend()phương pháp trong ví dụ của bạn sẽ thay đổi xthay vì trả lại một giá trị hữu ích (màreduce() hy vọng).

Một cách nhanh hơn để làm reducephiên bản sẽ là

>>> import operator
>>> l = [[1,2,3],[4,5,6], [7], [8,9]]
>>> reduce(operator.concat, l)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Đừng phát minh lại bánh xe nếu bạn sử dụng Django :

>>> from django.contrib.admin.utils import flatten
>>> l = [[1,2,3], [4,5], [6]]
>>> flatten(l)
>>> [1, 2, 3, 4, 5, 6]

... Gấu trúc :

>>> from pandas.core.common import flatten
>>> list(flatten(l))

... Itertools :

>>> import itertools
>>> flatten = itertools.chain.from_iterable
>>> list(flatten(l))

... Matplotlib

>>> from matplotlib.cbook import flatten
>>> list(flatten(l))

... Đơn phương :

>>> from unipath.path import flatten
>>> list(flatten(l))

... setuptools :

>>> from setuptools.namespaces import flatten
>>> list(flatten(l))

Đây là một cách tiếp cận chung áp dụng cho số , chuỗi , danh sách lồng nhau và hỗn hợp thùng chứa .

Mã

#from typing import Iterable 
from collections import Iterable                            # < py38


def flatten(items):
    """Yield items from any nested iterable; see Reference."""
    for x in items:
        if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
            for sub_x in flatten(x):
                yield sub_x
        else:
            yield x

Ghi chú :

• Trong Python 3, yield from flatten(x) có thể thay thếfor sub_x in flatten(x): yield sub_x
• Trong Python 3.8, lớp cơ sở trừu tượng được chuyển từ collection.abcvào typingmô-đun.

Bản giới thiệu

lst = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
list(flatten(lst))                                         # nested lists
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

mixed = [[1, [2]], (3, 4, {5, 6}, 7), 8, "9"]              # numbers, strs, nested & mixed
list(flatten(mixed))
# [1, 2, 3, 4, 5, 6, 7, 8, '9']

Tài liệu tham khảo

• Giải pháp này được sửa đổi từ một công thức trong Beazley, D. và B. Jones. Công thức 4.14, Python Cookbook 2nd Ed., O'Reilly Media Inc. Sebastopol, CA: 2013.
• Tìm thấy một bài viết SO trước đó , có thể là các cuộc biểu tình ban đầu.

Nếu bạn muốn làm phẳng cấu trúc dữ liệu mà bạn không biết nó được lồng sâu đến mức nào, bạn có thể sử dụng ¹iteration_utilities.deepflatten

>>> from iteration_utilities import deepflatten

>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
>>> list(deepflatten(l, depth=1))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> l = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
>>> list(deepflatten(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Đó là một trình tạo, do đó bạn cần đưa kết quả thành một listhoặc lặp lại rõ ràng trên nó.

Để làm phẳng chỉ một cấp độ và nếu mỗi mục tự lặp lại, bạn cũng có thể sử dụng iteration_utilities.flattenchính nó chỉ là một lớp bọc mỏng xung quanh itertools.chain.from_iterable:

>>> from iteration_utilities import flatten
>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
>>> list(flatten(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Chỉ cần thêm một số thời gian (dựa trên câu trả lời của Nico Schlömer không bao gồm chức năng được trình bày trong câu trả lời này):

Đó là một biểu đồ log-log để phù hợp với phạm vi giá trị khổng lồ được kéo dài. Đối với lý luận định tính: Thấp hơn là tốt hơn.

Kết quả cho thấy rằng nếu iterable chỉ chứa một vài lần lặp bên trong thì sumsẽ nhanh nhất, tuy nhiên đối với các lần lặp dài chỉ itertools.chain.from_iterable, iteration_utilities.deepflattenhoặc sự hiểu biết lồng nhau có hiệu suất hợp lý với itertools.chain.from_iterabletốc độ nhanh nhất (như đã được chú ý bởi Nico Schlömer).

from itertools import chain
from functools import reduce
from collections import Iterable  # or from collections.abc import Iterable
import operator
from iteration_utilities import deepflatten

def nested_list_comprehension(lsts):
    return [item for sublist in lsts for item in sublist]

def itertools_chain_from_iterable(lsts):
    return list(chain.from_iterable(lsts))

def pythons_sum(lsts):
    return sum(lsts, [])

def reduce_add(lsts):
    return reduce(lambda x, y: x + y, lsts)

def pylangs_flatten(lsts):
    return list(flatten(lsts))

def flatten(items):
    """Yield items from any nested iterable; see REF."""
    for x in items:
        if isinstance(x, Iterable) and not isinstance(x, (str, bytes)):
            yield from flatten(x)
        else:
            yield x

def reduce_concat(lsts):
    return reduce(operator.concat, lsts)

def iteration_utilities_deepflatten(lsts):
    return list(deepflatten(lsts, depth=1))


from simple_benchmark import benchmark

b = benchmark(
    [nested_list_comprehension, itertools_chain_from_iterable, pythons_sum, reduce_add,
     pylangs_flatten, reduce_concat, iteration_utilities_deepflatten],
    arguments={2**i: [[0]*5]*(2**i) for i in range(1, 13)},
    argument_name='number of inner lists'
)

b.plot()

^{1 Tuyên bố miễn trừ trách nhiệm: Tôi là tác giả của thư viện đó}

Tôi lấy lại tuyên bố của mình. tổng không phải là người chiến thắng. Mặc dù nó nhanh hơn khi danh sách nhỏ. Nhưng hiệu suất suy giảm đáng kể với danh sách lớn hơn.

>>> timeit.Timer(
        '[item for sublist in l for item in sublist]',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]] * 10000'
    ).timeit(100)
2.0440959930419922

Phiên bản sum vẫn đang chạy trong hơn một phút và chưa xử lý xong!

Đối với danh sách trung bình:

>>> timeit.Timer(
        '[item for sublist in l for item in sublist]',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]] * 10'
    ).timeit()
20.126545906066895
>>> timeit.Timer(
        'reduce(lambda x,y: x+y,l)',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]] * 10'
    ).timeit()
22.242258071899414
>>> timeit.Timer(
        'sum(l, [])',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]] * 10'
    ).timeit()
16.449732065200806

Sử dụng danh sách nhỏ và thời gian: number = 1000000

>>> timeit.Timer(
        '[item for sublist in l for item in sublist]',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]'
    ).timeit()
2.4598159790039062
>>> timeit.Timer(
        'reduce(lambda x,y: x+y,l)',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]'
    ).timeit()
1.5289170742034912
>>> timeit.Timer(
        'sum(l, [])',
        'l=[[1, 2, 3], [4, 5, 6, 7, 8], [1, 2, 3, 4, 5, 6, 7]]'
    ).timeit()
1.0598428249359131

Dường như có một sự nhầm lẫn với operator.add! Khi bạn thêm hai danh sách với nhau, thuật ngữ chính xác cho điều đó là concat, không thêm. operator.concatlà những gì bạn cần sử dụng.

Nếu bạn đang suy nghĩ chức năng, nó dễ như thế này ::

>>> from functools import reduce
>>> list2d = ((1, 2, 3), (4, 5, 6), (7,), (8, 9))
>>> reduce(operator.concat, list2d)
(1, 2, 3, 4, 5, 6, 7, 8, 9)

Bạn thấy giảm tôn trọng loại trình tự, vì vậy khi bạn cung cấp một tuple, bạn sẽ nhận lại một tuple. Hãy thử với một danh sách ::

>>> list2d = [[1, 2, 3],[4, 5, 6], [7], [8, 9]]
>>> reduce(operator.concat, list2d)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Aha, bạn nhận lại một danh sách.

Làm thế nào về hiệu suất ::

>>> list2d = [[1, 2, 3],[4, 5, 6], [7], [8, 9]]
>>> %timeit list(itertools.chain.from_iterable(list2d))
1000000 loops, best of 3: 1.36 µs per loop

from_iterablelà khá nhanh! Nhưng nó không so sánh để giảm với concat.

>>> list2d = ((1, 2, 3),(4, 5, 6), (7,), (8, 9))
>>> %timeit reduce(operator.concat, list2d)
1000000 loops, best of 3: 492 ns per loop

Tại sao bạn sử dụng mở rộng?

reduce(lambda x, y: x+y, l)

Điều này sẽ làm việc tốt.

Xem xét việc cài đặt more_itertoolsgói.

> pip install more_itertools

Nó vận chuyển với một triển khai cho flatten( nguồn , từ các công thức nấu ăn của itertools ):

import more_itertools


lst = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
list(more_itertools.flatten(lst))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Kể từ phiên bản 2.4, bạn có thể làm phẳng các vòng lặp lồng nhau phức tạp hơn với more_itertools.collapse ( nguồn , được đóng góp bởi abarnet).

lst = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
list(more_itertools.collapse(lst)) 
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

lst = [[1, 2, 3], [[4, 5, 6]], [[[7]]], 8, 9]              # complex nesting
list(more_itertools.collapse(lst))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Lý do chức năng của bạn không hoạt động là vì phần mở rộng mở rộng một mảng tại chỗ và không trả về nó. Bạn vẫn có thể trả về x từ lambda, bằng cách sử dụng một cái gì đó như thế này:

reduce(lambda x,y: x.extend(y) or x, l)

Lưu ý: tiện ích mở rộng hiệu quả hơn + trên danh sách.

def flatten(l, a):
    for i in l:
        if isinstance(i, list):
            flatten(i, a)
        else:
            a.append(i)
    return a

print(flatten([[[1, [1,1, [3, [4,5,]]]], 2, 3], [4, 5],6], []))

# [1, 1, 1, 3, 4, 5, 2, 3, 4, 5, 6]

Phiên bản đệ quy

x = [1,2,[3,4],[5,[6,[7]]],8,9,[10]]

def flatten_list(k):
    result = list()
    for i in k:
        if isinstance(i,list):

            #The isinstance() function checks if the object (first argument) is an 
            #instance or subclass of classinfo class (second argument)

            result.extend(flatten_list(i)) #Recursive call
        else:
            result.append(i)
    return result

flatten_list(x)
#result = [1,2,3,4,5,6,7,8,9,10]

matplotlib.cbook.flatten() sẽ làm việc cho các danh sách lồng nhau ngay cả khi chúng lồng sâu hơn ví dụ.

import matplotlib
l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
print(list(matplotlib.cbook.flatten(l)))
l2 = [[1, 2, 3], [4, 5, 6], [7], [8, [9, 10, [11, 12, [13]]]]]
print list(matplotlib.cbook.flatten(l2))

Kết quả:

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

Tốc độ này nhanh hơn 18 lần so với gạch dưới ._. Flatten:

Average time over 1000 trials of matplotlib.cbook.flatten: 2.55e-05 sec
Average time over 1000 trials of underscore._.flatten: 4.63e-04 sec
(time for underscore._)/(time for matplotlib.cbook) = 18.1233394636

Câu trả lời được chấp nhận không hoạt động với tôi khi xử lý các danh sách dựa trên văn bản có độ dài thay đổi. Đây là một cách tiếp cận thay thế đã làm việc cho tôi.

l = ['aaa', 'bb', 'cccccc', ['xx', 'yyyyyyy']]

Câu trả lời được chấp nhận không hoạt động:

flat_list = [item for sublist in l for item in sublist]
print(flat_list)
['a', 'a', 'a', 'b', 'b', 'c', 'c', 'c', 'c', 'c', 'c', 'xx', 'yyyyyyy']

Giải pháp đề xuất mới đã làm việc cho tôi:

flat_list = []
_ = [flat_list.extend(item) if isinstance(item, list) else flat_list.append(item) for item in l if item]
print(flat_list)
['aaa', 'bb', 'cccccc', 'xx', 'yyyyyyy']

Một tính năng xấu của chức năng Anil ở trên là nó yêu cầu người dùng luôn chỉ định thủ công đối số thứ hai là một danh sách trống []. Điều này thay vào đó nên là một mặc định. Do cách thức hoạt động của các đối tượng Python, chúng nên được đặt bên trong hàm chứ không phải trong các đối số.

Đây là một chức năng làm việc:

def list_flatten(l, a=None):
    #check a
    if a is None:
        #initialize with empty list
        a = []

    for i in l:
        if isinstance(i, list):
            list_flatten(i, a)
        else:
            a.append(i)
    return a

Kiểm tra:

In [2]: lst = [1, 2, [3], [[4]],[5,[6]]]

In [3]: lst
Out[3]: [1, 2, [3], [[4]], [5, [6]]]

In [11]: list_flatten(lst)
Out[11]: [1, 2, 3, 4, 5, 6]

Theo tôi có vẻ đơn giản nhất:

>>> import numpy as np
>>> l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
>>> print (np.concatenate(l))
[1 2 3 4 5 6 7 8 9]

Người ta cũng có thể sử dụng căn hộ NumPy :

import numpy as np
list(np.array(l).flat)

Chỉnh sửa 11/02/2016: Chỉ hoạt động khi danh sách phụ có kích thước giống hệt nhau.

Bạn có thể sử dụng numpy:
flat_list = list(np.concatenate(list_of_list))

Nếu bạn sẵn sàng từ bỏ một tốc độ nhỏ để có vẻ ngoài gọn gàng hơn, thì bạn có thể sử dụng numpy.concatenate().tolist()hoặc numpy.concatenate().ravel().tolist():

import numpy

l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]] * 99

%timeit numpy.concatenate(l).ravel().tolist()
1000 loops, best of 3: 313 µs per loop

%timeit numpy.concatenate(l).tolist()
1000 loops, best of 3: 312 µs per loop

%timeit [item for sublist in l for item in sublist]
1000 loops, best of 3: 31.5 µs per loop

Bạn có thể tìm hiểu thêm ở đây trong các tài liệu numpy.concatenate và numpy.ravel

Giải pháp nhanh nhất tôi đã tìm thấy (cho danh sách lớn nào):

import numpy as np
#turn list into an array and flatten()
np.array(l).flatten()

Làm xong! Tất nhiên bạn có thể biến nó trở lại thành một danh sách bằng cách thực hiện danh sách (l)

Mã đơn giản cho underscore.pyquạt gói

from underscore import _
_.flatten([[1, 2, 3], [4, 5, 6], [7], [8, 9]])
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Nó giải quyết tất cả các vấn đề làm phẳng (không có mục danh sách hoặc lồng phức tạp)

from underscore import _
# 1 is none list item
# [2, [3]] is complex nesting
_.flatten([1, [2, [3]], [4, 5, 6], [7], [8, 9]])
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

Bạn có thể cài đặt underscore.pyvới pip

pip install underscore.py

def flatten(alist):
    if alist == []:
        return []
    elif type(alist) is not list:
        return [alist]
    else:
        return flatten(alist[0]) + flatten(alist[1:])

Lưu ý : Dưới đây áp dụng cho Python 3.3+ vì nó sử dụng yield_from. sixcũng là gói của bên thứ ba, mặc dù nó ổn định. Thay phiên, bạn có thể sử dụng sys.version.

Trong trường hợp obj = [[1, 2,], [3, 4], [5, 6]], tất cả các giải pháp ở đây đều tốt, bao gồm hiểu danh sách vàitertools.chain.from_iterable .

Tuy nhiên, hãy xem xét trường hợp phức tạp hơn một chút này:

>>> obj = [[1, 2, 3], [4, 5], 6, 'abc', [7], [8, [9, 10]]]

Có một số vấn đề ở đây:

• Một yếu tố, 6 chỉ là một vô hướng; nó không lặp lại được, vì vậy các tuyến đường trên sẽ thất bại ở đây.
• Một yếu tố, 'abc', là iterable về mặt kỹ thuật (tất cảstr s là). Tuy nhiên, đọc giữa các dòng một chút, bạn không muốn coi nó như vậy - bạn muốn coi nó như một yếu tố duy nhất.
• Phần tử cuối cùng, [8, [9, 10]]chính nó là một vòng lặp lồng nhau. Hiểu danh sách cơ bản và chain.from_iterablechỉ trích xuất "1 cấp xuống."

Bạn có thể khắc phục điều này như sau:

>>> from collections import Iterable
>>> from six import string_types

>>> def flatten(obj):
...     for i in obj:
...         if isinstance(i, Iterable) and not isinstance(i, string_types):
...             yield from flatten(i)
...         else:
...             yield i


>>> list(flatten(obj))
[1, 2, 3, 4, 5, 6, 'abc', 7, 8, 9, 10]

Tại đây, bạn kiểm tra xem phần tử con (1) có thể lặp lại với Iterable, một ABC từ itertools, nhưng cũng muốn đảm bảo rằng (2) phần tử không "giống như chuỗi".

flat_list = []
for i in list_of_list:
    flat_list+=i

Mã này cũng hoạt động tốt vì nó chỉ mở rộng danh sách tất cả các cách. Mặc dù nó rất giống nhau nhưng chỉ có một vòng lặp. Vì vậy, nó có độ phức tạp ít hơn so với việc thêm 2 cho các vòng lặp.

from nltk import flatten

l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
flatten(l)

Ưu điểm của giải pháp này so với hầu hết các giải pháp khác ở đây là nếu bạn có một danh sách như:

l = [1, [2, 3], [4, 5, 6], [7], [8, 9]]

trong khi hầu hết các giải pháp khác đưa ra lỗi thì giải pháp này xử lý chúng.

Đây có thể không phải là cách hiệu quả nhất nhưng tôi nghĩ nên đặt một lớp lót (thực ra là hai lớp lót). Cả hai phiên bản sẽ hoạt động trên các danh sách phân cấp lồng nhau tùy ý và khai thác các tính năng ngôn ngữ (Python3.5) và đệ quy.

def make_list_flat (l):
    flist = []
    flist.extend ([l]) if (type (l) is not list) else [flist.extend (make_list_flat (e)) for e in l]
    return flist

a = [[1, 2], [[[[3, 4, 5], 6]]], 7, [8, [9, [10, 11], 12, [13, 14, [15, [[16, 17], 18]]]]]]
flist = make_list_flat(a)
print (flist)

Đầu ra là

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

Điều này hoạt động theo cách sâu đầu tiên. Đệ quy đi xuống cho đến khi nó tìm thấy một phần tử không có trong danh sách, sau đó mở rộng biến cục bộ flistvà sau đó cuộn nó lại cho cha mẹ. Bất cứ khi nào flistđược trả lại, nó được mở rộng cho phụ huynh flisttrong phần hiểu danh sách. Do đó, tại thư mục gốc, một danh sách phẳng được trả về.

Cái trên tạo ra một số danh sách địa phương và trả về chúng được sử dụng để mở rộng danh sách của cha mẹ. Tôi nghĩ rằng cách xung quanh cho điều này có thể đang tạo ra một sự sáng chói flist, như dưới đây.

a = [[1, 2], [[[[3, 4, 5], 6]]], 7, [8, [9, [10, 11], 12, [13, 14, [15, [[16, 17], 18]]]]]]
flist = []
def make_list_flat (l):
    flist.extend ([l]) if (type (l) is not list) else [make_list_flat (e) for e in l]

make_list_flat(a)
print (flist)

Đầu ra là một lần nữa

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]

Mặc dù tôi không chắc chắn vào lúc này về hiệu quả.

Một cách tiếp cận khác thường hoạt động cho danh sách các số nguyên không đồng nhất và đồng nhất:

from typing import List


def flatten(l: list) -> List[int]:
    """Flatten an arbitrary deep nested list of lists of integers.

    Examples:
        >>> flatten([1, 2, [1, [10]]])
        [1, 2, 1, 10]

    Args:
        l: Union[l, Union[int, List[int]]

    Returns:
        Flatted list of integer
    """
    return [int(i.strip('[ ]')) for i in str(l).split(',')]