리스트에서 플랫리스트를 작성하려면 어떻게 해야 하나요?

리스트에서 플랫리스트를 작성하려면 어떻게 해야 하나요?

이 목록 목록을 평평하게 만듭니다.

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

다음과 같이 입력합니다.

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

「」를 해 주세요.l ,

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

즉, 다음과 같습니다.

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

l의

대응하는 기능은 다음과 같습니다.

def flatten(l):
    return [item for sublist in l for item in sublist]

증거로 수 .timeit★★★★

$ 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

설명: 숏컷의 베이스는 다음과 같습니다.+)sum으로 ( ), ( ), ( ), ( ), ( ), ( ), ( ), ( ), ( ),O(L**2)L개의 서브리스트가 있는 경우 -- 중간 결과 리스트가 길어질수록 각 스텝에서 새로운 중간 결과 리스트 오브젝트가 할당되어 이전 중간 결과의 모든 아이템이 복사되어야 합니다(마지막에 추가된 몇 개의 새로운 아이템도 복사되어야 합니다., 각각 L개씩 첫되고, 두 뒤로 복사되고 두 번째 I 항목은 L-2번 복사됩니다. 총 복사본 수는 x의 합을 1에서 L까지 곱한 값입니다. 즉, 제외됩니다.I * (L**2)/2.

목록 이해는 한 번만 목록을 생성하고 각 항목을 (원래 거주지에서 결과 목록으로) 정확하게 한 번 복사합니다.

다음을 사용할 수 있습니다.

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

또는 를 사용하여 목록을 압축 해제하지 않아도 됩니다.*★★★★★★★★★★★★★★★★★★:

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

더 것입니다.[item for sublist in l for item in sublist] 빠른 처럼 보입니다: 더 빠른 것 같습니다.

$ python3 -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99;import itertools' 'list(itertools.chain.from_iterable(l))'
20000 loops, best of 5: 10.8 usec per loop
$ python3 -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 5: 21.7 usec per loop
$ python3 -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'sum(l, [])'
1000 loops, best of 5: 258 usec per loop
$ python3 -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99;from functools import reduce' 'reduce(lambda x,y: x+y,l)'
1000 loops, best of 5: 292 usec per loop
$ python3 --version
Python 3.7.5rc1

작성자의 주의사항:이것은 매우 비효율적이다.하지만 재밌어요. 왜냐하면 모노이드는 멋져요

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

sum할 수 있는 xss[]은 ( )입니다.0(어느 쪽인가 하면)

하고 있기 에, 실제로는 「」를 취득됩니다.[1,3]+[2,4]의 sum([[1,3],[2,4]],[])은 '먹다'와 [1,3,2,4].

는 목록 목록에서만 작동합니다.목록 목록을 보려면 다른 솔루션이 필요합니다.

나는 perfplot(애완동물 프로젝트, 기본적으로 랩퍼)로 대부분의 제안 솔루션을 테스트했다.timeit를 발견하였습니다.

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

다수의 작은 리스트와 소수의 긴 리스트가 연결되어 있는 경우 모두 가장 빠른 솔루션이 됩니다.(operator.iadd마찬가지로 빠릅니다.)

보다 단순하면서도 허용 가능한 변형은 다음과 같습니다.

out = []
for sublist in a:
    out.extend(sublist)

서브 리스트의 수가 많은 경우는, 상기의 제안보다 약간 퍼포먼스가 저하합니다.

---

플롯을 재현하는 코드:

import functools
import itertools
import operator

import numpy as np
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(np.array(a).flat)


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


def extend(a):
    out = []
    for sublist in a:
        out.extend(sublist)
    return out


b = perfplot.bench(
    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,
        extend,
    ],
    n_range=[2 ** k for k in range(16)],
    xlabel="num lists (of length 10)",
    # xlabel="len lists (10 lists total)"
)
b.save("out.png")
b.show()

를 사용하여 누적 목록을 추가합니다.xs ys:

from functools import reduce
xss = [[1,2,3], [4,5,6], [7], [8,9]]
out = reduce(lambda xs, ys: xs + ys, xss)

출력:

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

---

다음을 사용하여 보다 빠른 방법:

from functools import reduce
import operator
xss = [[1,2,3], [4,5,6], [7], [8,9]]
out = reduce(operator.concat, xss)

출력:

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

다음은 숫자, 문자열, 중첩 목록 및 혼합 컨테이너에 적용되는 일반적인 방법입니다.이렇게 하면 단순 컨테이너와 복잡한 컨테이너를 모두 평평하게 만들 수 있습니다(데모 참조).

코드

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

주의:

• 3, Python 3의 경우yield from flatten(x)할 수 for sub_x in flatten(x): yield sub_x
• Python 3.8에서는 추상 기본 클래스가 다음에서 이동됩니다.collection.abctyping★★★★★★ 。

데모

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

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

언급

• 이 용액은 비즐리, D, B의 레시피에서 수정한 것이다. 존스 레시피 4.14, 파이썬 쿡북 3판, 오라일리 미디어 주식회사 세바스토폴, 캘리포니아: 2013년.
• 이전의 SO 포스트를 찾았습니다. 아마도 원래 시연일 겁니다.

깊이 중첩된 데이터 구조를 평평하게 만들려면 다음과 같이 사용합니다.

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

이것은 발전기이기 때문에 당신은 결과를 캐스트해야 합니다.list아니면 명시적으로 반복할 수도 있습니다.

---

하나의 레벨만 평평하게 하고 각 아이템이 반복 가능한 경우 얇은 랩에 둘러싸인 것을 사용할 수도 있습니다.

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

---

타이밍을 추가하는 것(이 답변에 제시된 기능이 포함되지 않은 Nico Schlömer의 답변에 근거함)

로그 로그 플롯으로, 광범위한 가치를 수용할 수 있습니다.질적 추론의 경우: 작을수록 좋습니다.

반복 이 몇 , "반복 가능"은 "반복가능"은 "반복 가능"입니다.sum만, 긴 는, 「반복할 수 있다」, 「반복할 수 없다」, 「반복할 수 없다」, 「반복할 수 없다」, 「반복할 수 없다」, 「반복할 수 없다」, 「반복할 수 없다」만,itertools.chain.from_iterable,iteration_utilities.deepflatten 가 있습니다.itertools.chain.from_iterable(니코 슐뢰머가 이미 눈치챘듯이) 가장 빠르다.

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 면책사항:제가 그 도서관의 저자예요.}

다음은 가장 간단한 것 같습니다.

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

패키지의 인스톨을 검토해 주세요.

> pip install more_itertools

이 제품에는 (소스, retertools 레시피에서) 다음과 같은 구현이 포함되어 있습니다.

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]

주의: 문서에서 설명한 바와 같이flatten에는 목록 목록이 필요합니다.불규칙한 입력의 평탄화에 대해서는, 이하를 참조해 주세요.

---

버전 2.4부터는 (소스, 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]

기능이 작동하지 않는 이유는 익스텐트가 어레이를 인플레이스 확장하여 반환하지 않기 때문입니다.다음과 같은 방법으로 람다에서 x를 반환할 수 있습니다.

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

주의: 목록의 +보다 확장이 효율적입니다.

matplotlib.cbook.flatten()는, 된 다 더 에서도 기능합니다.

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)))

결과:

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

이는 언더스코어보다 18배 빠른 속도입니다. 플랫텐:

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

의 리스트에 [[1, 2, 3], [4, 5, 6], [7], [8, 9]]인 1개의 목록 수준을 간단하게 할 수 .sum(list,[]) 라이브러리도 하지 않고

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

내부에 태플 또는 번호가 존재하는 경우 이 방법의 장점을 확장합니다. 매핑 만으로, 각 요소에 매핑 을 추가할 수 .map

#For only tuple
sum(list(map(list,[[1, 2, 3], (4, 5, 6), (7,), [8, 9]])),[])
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

#In general

def convert(x):
    if type(x) is int or type(x) is float:
           return [x]
    else:
           return list(x)

sum(list(map(convert,[[1, 2, 3], (4, 5, 6), 7, [8, 9]])),[])
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

여기에서는, 이 어프로치의 메모리 면에서의 결점에 대해 명확하게 설명합니다.즉, 리스트 오브젝트를 재귀적으로 작성합니다.이러한 오브젝트는 피해야 합니다.

NumPy의 플랫도 사용할 수 있습니다.

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

하위 목록의 치수가 동일한 경우에만 작동합니다.

의 2를 사용합니다.for록록: :

l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
flat_l = [e for v in l for e in v]
print(flat_l)

.list extend가장 빠른 것으로 나타납니다.

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

퍼포먼스:

import functools
import itertools
import numpy
import operator
import perfplot


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 extend(a):
    n = []

    list(map(n.extend, a))

    return n


perfplot.show(
    setup = lambda n: [list(range(10))] * n,
    kernels = [
        functools_reduce_iconcat, extend, itertools_chain, numpy_flat
        ],
    n_range = [2**k for k in range(16)],
    xlabel = 'num lists',
    )

출력:

과 같은 이 여러 개 도 이 방법을 .try이를 통해 솔루션을 더욱 견고하고 피토닉하게 만들 수 있습니다.

def flatten(itr):
    for x in itr:
        try:
            yield from flatten(x)
        except TypeError:
            yield x

용도: 이것은 제너레이터입니다.일반적으로 다음과 같은 반복 가능한 빌더에 동봉하는 것이 좋습니다.list() ★★★★★★★★★★★★★★★★★」tuple()을 사용하세요.forloopsyslog.syslog..syslog.

이 솔루션의 장점은 다음과 같습니다.

• 모든 종류의 반복 가능한 기능(미래에도 사용 가능)을 갖추고 있습니다.
• 둥지의 어떤 조합과 깊이에도 효과가 있다
• 최상위 레벨에 베어 아이템이 포함되어 있는 경우에도 기능합니다.
• 의존 관계 없음
• 빠르고 효율적입니다(필요 없는 나머지 부분에 시간을 낭비하지 않고 부분적으로 반복 가능한 중첩된 부분을 평평하게 만들 수 있습니다).
• 다용도(선택한 반복 가능한 구성 또는 루프 형태로 구성하기 위해 사용할 수 있습니다.

N.B.: 모든 반복 가능 항목이 평평하기 때문에 문자열은 단일 문자로 분해됩니다.이러한 동작이 마음에 들지 않는 경우는, 문자열이나 바이트등의 반복 가능성의 편평화를 제외하는 다음의 버전을 사용할 수 있습니다.

def flatten(itr):
    if type(itr) in (str,bytes):
        yield itr
    else:
        for x in itr:
            try:
                yield from flatten(x)
            except TypeError:
                yield x

룩을 , ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★numpy.concatenate().tolist() ★★★★★★★★★★★★★★★★★」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

상세한 것에 대하여는, 메뉴얼 「numpy.concatenate」및 「numpy.ravel」을 참조해 주세요.

주의: 아래는 Python 3.3+를 사용하기 때문에 적용됩니다.six는 서드파티제 패키지이지만 안정적입니다.는을 사용할 .sys.version.

---

obj = [[1, 2,], [3, 4], [5, 6]] 및 를 한 모든 itertools.chain.from_iterable.

다만, 조금 더 복잡한 경우를 생각해 봅시다.

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

여기에는 몇 가지 문제가 있습니다.

• 의 요소, 「」는, 「」입니다.6을 사용하다반복할 수 없기 때문에 위의 루트는 여기서 실패합니다.
• 의 요소, 「」는, 「」입니다.'abc'기술적으로 반복할 수 있습니다(모두).strs는). 단, 행간을 조금 읽으면, 그렇게 취급하는 것이 아니라 단일 요소로 취급하는 것이 좋습니다.
• 요소인 '아예'는 '아예'[8, [9, 10]]그 자체가 반복할 수 있는 중첩입니다. 목록 및 목록 이해chain.from_iterable1'은 '1'은 '1'은 '1'은 '1'입니다.

이 문제는 다음과 같이 해결할 수 있습니다.

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

여기에서는 서브 요소(1)가 에서의 ABC와 반복 가능한 것을 확인합니다.itertools단, (2) 요소가 "string-like"가 아님을 확인합니다.

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

는 여러 개의둥지를 틀 수 .[[1], [[[2]], [3]]], [1, 2, 3]예를 들어 재귀적이지 않습니다(재귀가 크고 재귀 오류가 발생했습니다.

제가 생각해낸 건 다음과 같습니다.

def _flatten(l) -> Iterator[Any]:
    stack = l.copy()
    while stack:
        item = stack.pop()
        if isinstance(item, list):
            stack.extend(item)
        else:
            yield item


def flatten(l) -> Iterator[Any]:
    return reversed(list(_flatten(l)))

및 테스트:

@pytest.mark.parametrize('input_list, expected_output', [
    ([1, 2, 3], [1, 2, 3]),
    ([[1], 2, 3], [1, 2, 3]),
    ([[1], [2], 3], [1, 2, 3]),
    ([[1], [2], [3]], [1, 2, 3]),
    ([[1], [[2]], [3]], [1, 2, 3]),
    ([[1], [[[2]], [3]]], [1, 2, 3]),
])
def test_flatten(input_list, expected_output):
    assert list(flatten(input_list)) == expected_output

이것이 가장 효율적인 방법은 아닐지도 모르지만, 저는 원라이너(실제로는 투라이너)를 넣으려고 생각했습니다.두 버전 모두 임의의 계층 중첩 목록에서 작동하며 언어 기능(Python 3.5) 및 재귀 기능을 이용합니다.

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)

출력은

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

이것은 우선 깊이 있는 방식으로 작용합니다.요소가 된 후 로컬 「」를 합니다.flist언제 어디서든flist, , 부모로 확장됩니다.flist목록 이해에 있어.따라서 루트에서는 플랫리스트가 반환됩니다.

위의 항목은 여러 로컬 목록을 만들고 부모 목록을 확장하는 데 사용되는 목록을 반환합니다. 합니다.flist이하와 같이.

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)

출력은 다시

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

현재로서는 효율에 대해서는 잘 모르겠습니다.

원라이너는 아니지만, 여기 있는 모든 답변을 보면, 이 긴 리스트는 패턴 매칭을 놓친 것 같습니다.여기 있습니다.

이 두 가지 방법은 효율적이지 않을 수 있지만, 어쨌든 읽기 쉽습니다(적어도 기능적 프로그래밍으로 인해 망가진 것 같습니다).

def flat(x):
    match x:
        case []:
            return []
        case [[*sublist], *r]:
            return [*sublist, *flat(r)]

두 번째 버전에서는 목록 목록을 고려합니다.네스팅이 무엇이든:

def flat(x):
    match x:
        case []:
            return []
        case [[*sublist], *r]:
            return [*flat(sublist), *flat(r)]
        case [h, *r]:
            return [h, *flat(r)]

이질적 및 동질적 정수 목록에 적용되는 또 다른 특이한 접근법:

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(',')]

모든 깊이의 목록 목록을 평평하게 만드는 비재귀 함수:

def flatten_list(list1):
    out = []
    inside = list1
    while inside:
        x = inside.pop(0)
        if isinstance(x, list):
            inside[0:0] = x
        else:
            out.append(x)
    return out

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

모든 요소를 제거하고 개별 요소 목록을 유지하려면 이 옵션을 사용할 수도 있습니다.

list_of_lists = [[1,2], [2,3], [3,4]]
list(set.union(*[set(s) for s in list_of_lists]))

다음을 사용할 수 있습니다.

def flatlst(lista):
    listaplana = []
    for k in lista: listaplana = listaplana + k
    return listaplana

수율표와 수율표가 있는 발전기를 사용하는 것이 좋습니다.다음은 예를 제시하겠습니다.

from collections.abc import Iterable

def flatten(items, ignore_types=(bytes, str)):
    """
       Flatten all of the nested lists to the one. Ignoring flatting of iterable types str and bytes by default.
    """
    for x in items:
        if isinstance(x, Iterable) and not isinstance(x, ignore_types):
            yield from flatten(x)
        else:
            yield x

values = [7, [4, 3, 5, [7, 3], (3, 4), ('A', {'B', 'C'})]]

for v in flatten(values):
    print(v)

것이 , 재귀적인 저의 .flatten중첩된 목록뿐만 아니라 주어진 컨테이너 또는 항목을 버릴 수 있는 일반적으로 모든 개체를 평평하게 만들 수 있는 함수입니다.이는 모든 중첩 깊이에서도 작동하며 요청에 따라 항목을 생성하는 느린 반복 기능입니다.

def flatten(iterable):
    # These types won't considered a sequence or generally a container
    exclude = str, bytes

    for i in iterable:
        try:
            if isinstance(i, exclude):
                raise TypeError
            iter(i)
        except TypeError:
            yield i
        else:
            yield from flatten(i)

평평하게뺄 수 있어요.str이치노

이 사물을 할 수 입니다.iter()이치노따라서 반복 가능한 개체는 생성기 표현식을 항목으로 가질 수 있습니다.

누군가는 주장할 수 있다:작전본부에서 요청하지도 않았는데 왜 그렇게 일반적이지?그래요, 당신 말이 옳다구요.나는 단지 이것이 누군가에게 도움이 될 수 있을 것 같았다(나 자신을 위해 그랬던 것처럼).

테스트 케이스:

lst1 = [1, {3}, (1, 6), [[3, 8]], [[[5]]], 9, ((((2,),),),)]
lst2 = ['3', B'A', [[[(i ** 2 for i in range(3))]]], range(3)]

print(list(flatten(lst1)))
print(list(flatten(lst2)))

출력:

[1, 3, 1, 6, 3, 8, 5, 9, 2]
['3', b'A', 0, 1, 4, 0, 1, 2]

여기에 여러 개의 목록이 포함된 목록의 경우, 나에게 적합한 재귀적 해결 방법이 있습니다.

# Question 4
def flatten(input_ls=[]) -> []:
    res_ls = []
    res_ls = flatten_recursive(input_ls, res_ls)

    print("Final flatten list solution is: \n", res_ls)

    return res_ls


def flatten_recursive(input_ls=[], res_ls=[]) -> []:
    tmp_ls = []

    for i in input_ls:
        if isinstance(i, int):
            res_ls.append(i)
        else:
            tmp_ls = i
            tmp_ls.append(flatten_recursive(i, res_ls))

    print(res_ls)
    return res_ls


flatten([0, 1, [2, 3], 4, [5, 6]])  # test
flatten([0, [[[1]]], [[2, 3], [4, [[5, 6]]]]])

출력:

[0, 1, 2, 3]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
Final flatten list solution is: 
 [0, 1, 2, 3, 4, 5, 6]
[0, 1]
[0, 1]
[0, 1]
[0, 1, 2, 3]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
Final flatten list solution is: 
 [0, 1, 2, 3, 4, 5, 6]

목록에 정수만 있는 경우:

import re
l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]
list(map(int,re.sub('(\[|\])','',str(l)).split(',')))

언급URL : https://stackoverflow.com/questions/952914/how-do-i-make-a-flat-list-out-of-a-list-of-lists