Python'daki listelerden basit bir liste yapmak için bir kısayol olup olmadığını merak ediyorum.

Bunu bir fordöngü içinde yapabilirim , ama belki bazı serin "bir astar" var? İle denedim reduce(), ama bir hata alıyorum.

kod

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

Hata mesajı

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

Liste listesi verildiğinde l,

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

bunun anlamı:

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

şu ana kadar yayınlanan kısayollardan daha hızlı. ( ldüzleştirilecek listedir.)

İşte ilgili fonksiyon:

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

Kanıt olarak, timeitmodülü standart kütüphanede kullanabilirsiniz:

$ 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

Açıklama: dayalı kısayollar +(içinde zımni kullanımı dahil sum) olan, gereklilik, O(L**2)- ara sonuç listesi yeni ara sonuç listesi nesnesi tahsis alır her adımda, uzun olmaya devam ediyor gibi ve tüm öğeleri ne zaman orada L Alt listeler vardır önceki ara sonuçta kopyalanmalı (ve sonuna birkaç yenisi eklenmelidir). Yani, basitlik ve fiili genel kayıp olmadan, her biri I öğenin L alt listesine sahip olduğunuzu varsayalım: ilk I öğeleri L-1 kez ileri ve geri kopyalanır, ikinci I öğeleri L-2 kez vb. toplam kopya sayısı, 1'den x'e hariç x için x toplamının çarpımının çarpımıdır, yani I * (L**2)/2.

Liste kavraması yalnızca bir kez bir liste oluşturur ve her öğeyi (orijinal ikamet yerinden sonuç listesine) tam olarak bir kez kopyalar.

Şunları kullanabilirsiniz itertools.chain():

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

Veya itertools.chain.from_iterable()listenin *operatörle birlikte paketlenmesini gerektirmeyen kullanabilirsiniz :

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

Yazardan not : Bu verimsiz. Ama eğlenceli, çünkü monoidler harika. Üretim Python kodu için uygun değildir.

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

Bu sadece birinci argümanda geçirilen yinelenebilir unsurları toplar, ikinci argümanı toplamın başlangıç ​​değeri olarak ele alır (eğer verilmezse, 0kullanılır ve bu durumda size bir hata verecektir).

İç içe listeler topladığınız için, aslında [1,3]+[2,4]bunun sonucunda sum([[1,3],[2,4]],[])eşittir [1,3,2,4].

Yalnızca liste listelerinde çalıştığını unutmayın. Liste listelerinin listeleri için başka bir çözüme ihtiyacınız vardır.

Perfplot (benim için bir evcil hayvan projesi, aslında bir sarıcı timeit) ile en çok önerilen çözümleri test ettim ve buldum

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

birçok küçük liste ve birkaç uzun liste birleştirildiğinde en hızlı çözüm olmaktır. ( operator.iaddeşit derecede hızlı.)

Grafiği yeniden oluşturmak için kod:

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]

extend()Daki örnekte yöntem, modifiye xyerine (faydalı bir değeri dönen reduce()bekler).

reduceSürümü yapmanın daha hızlı bir yolu

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

Django kullanıyorsanız tekerleği yeniden icat etmeyin :

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

... Pandalar :

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

... Unipath :

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

... Kurulum araçları :

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

İşte sayılar , karakter dizileri , iç içe listeler ve karışık kaplar için geçerli olan genel bir yaklaşım .

kod

#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

Notlar :

• Python 3, yield from flatten(x)yerini alabilirfor sub_x in flatten(x): yield sub_x
• Python 3.8 içinde, soyut temel sınıfları vardır hareket gelen collection.abciçin typingmodül.

gösteri

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

Referans

• Bu çözelti Beazley, D. ve B. Jones'daki bir tariften modifiye edilmiştir . Reçete 4.14, Python Yemek Kitabı 3. Baskı, O'Reilly Media Inc. Sebastopol, CA: 2013.
• Muhtemelen orijinal gösteri olan daha eski bir SO yayını bulundu .

Eğer iç içe ne kadar derin olduğunu bilmiyorum bir veri yapısını düzleştirmek istiyorsanız kullanabilirsiniz ¹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]

Bu bir jeneratör, bu yüzden sonucu listaçık bir şekilde veya açıkça yinelemeniz gerekiyor.

Sadece bir seviye düzleştirmek ve her bir öğenin kendisi yinelenebilirse, kendisi iteration_utilities.flattenetrafında sadece ince bir sargı olan da kullanabilirsiniz 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]

Sadece bazı zamanlamalar eklemek için (bu cevapta sunulan işlevi içermeyen Nico Schlömer cevabına dayanarak):

Yayılmış çok çeşitli değerlere uyum sağlamak için bir günlük kaydı grafiğidir. Niteliksel akıl yürütme için: Düşük daha iyidir.

Sonuçlar iterable sadece birkaç iç Iterables içeriyorsa o zaman olduğunu göstermektedir sumuzun Iterables yalnızca bununla birlikte, en hızlı olacaktır itertools.chain.from_iterable, iteration_utilities.deepflattenmakul bir performansa sahip veya iç içe kavrama itertools.chain.from_iterable(zaten Nico Schlomer tarafından fark) en hızlı olmak.

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 Feragatname: Bu kütüphanenin yazarıyım}

İfademi geri alıyorum. toplam kazanan değil. Liste küçük olduğunda daha hızlı olmasına rağmen. Ancak performans, daha büyük listelerle önemli ölçüde düşer.

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

Toplam sürüm hala bir dakikadan fazla çalışıyor ve henüz işlenmedi!

Araç listeleri için:

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

Küçük listeler ve timeit kullanma: sayı = 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

Bir karışıklık var gibi görünüyor operator.add! İki listeyi birlikte eklediğinizde, bunun için doğru terim concateklemektir. operator.concatkullanmanız gereken şey bu.

Fonksiyonel düşünüyorsanız, bu kadar kolay ::

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

Dizi türüne saygıyı azalttığını görüyorsunuz, bu yüzden bir demet beslediğinizde, bir demet geri alırsınız. Bir liste ile deneyelim ::

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

Aha, bir listeyi geri getir.

Performans hakkında ::

>>> 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_iterableoldukça hızlı! Ama azaltmak için bir karşılaştırma yok 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

Neden expand kullanıyorsunuz?

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

Bu iyi olmalı.

more_itertoolsPaketi kurmayı düşünün .

> pip install more_itertools

Bir uygulama ile birlikte gönderilir flatten( kaynak , itertools tariflerinden ):

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]

2.4 sürümünden itibaren, daha karmaşık, iç içe yinelenebilirleri more_itertools.collapse( kaynak , abarnet'in katkıda bulunduğu) düzleştirebilirsiniz.

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]

İşlevinizin çalışmamasının nedeni, genişletmenin bir diziyi yerinde genişletmesi ve döndürmemesi. Yine de böyle bir şey kullanarak lambda'dan x döndürebilirsiniz:

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

Not: expand, listelerde + işaretinden daha etkilidir.

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]

Özyinelemeli sürüm

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() yuvalanmış listelerde, örnekten daha derin yuvalanmış olsalar bile çalışacaktır.

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

Sonuç:

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

Alt çizgiden 18 kat daha hızlıdır.

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

Değişken uzunluklardaki metin tabanlı listelerle uğraşırken kabul edilen cevap benim için çalışmadı. İşte benim için işe yarayan alternatif bir yaklaşım.

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

Did cevabı Kabul değil iş:

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

Yeni çözüm önerdi mi iş için beni:

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

Anil'nin yukarıdaki işlevinin kötü bir özelliği, kullanıcının boş bir liste olarak her zaman ikinci bağımsız değişkeni manuel olarak belirtmesini gerektirmesidir []. Bunun yerine bu bir varsayılan değer olmalıdır. Python nesnelerinin çalışma şekli nedeniyle, bunlar bağımsız değişkenlerde değil işlevin içinde ayarlanmalıdır.

İşte çalışan bir işlev:

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

Test yapmak:

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]

Aşağıdaki benim için en basit görünüyor:

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

Bir de numpy en kullanabilirsiniz düz :

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

Edit 11/02/2016: Yalnızca alt listelerin boyutları aynı olduğunda çalışır.

Numpy kullanabilirsiniz:
flat_list = list(np.concatenate(list_of_list))

Daha temiz bir görünüm için az miktarda hızdan vazgeçmek istiyorsanız, numpy.concatenate().tolist()veya seçeneğini kullanabilirsiniz 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

Daha fazla bilgiyi burada numpy.concatenate ve numpy.ravel belgelerinde bulabilirsiniz.

Bulduğum en hızlı çözüm (yine de büyük liste için):

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

Bitti! Elbette listeyi (l) yürüterek tekrar listeye dönüştürebilirsiniz.

underscore.pyPaket fanı için basit kod

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

Tüm düzleştirme sorunlarını çözer (hiçbir liste öğesi veya karmaşık iç içe geçme)

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]

underscore.pyPip ile kurabilirsiniz

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

Not : Aşağıda, Python 3.3+ için kullanıldığı için geçerlidir yield_from. sixkararlı olmasına rağmen, üçüncü taraf bir pakettir. Alternatif olarak kullanabilirsiniz sys.version.

Bu durumda, obj = [[1, 2,], [3, 4], [5, 6]]liste kavraması ve dahil olmak üzere buradaki tüm çözümler iyidir itertools.chain.from_iterable.

Ancak, bu biraz daha karmaşık bir durumu düşünün:

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

Burada birkaç sorun var:

• Bir element, 6sadece bir skalerdir; yinelenebilir değil, bu yüzden yukarıdaki yollar burada başarısız olacak.
• Bir eleman, 'abc', olup (teknik olarak iterable strs) vardır. Bununla birlikte, çizgiler arasında biraz okumak, ona böyle davranmak istemiyorsunuz - tek bir eleman olarak ele almak istiyorsunuz.
• Son elemanın [8, [9, 10]]kendisi, iç içe geçmiş bir yinelenebilirdir. Temel liste anlama ve chain.from_iterablesadece "1 seviye aşağı" ayıklayın.

Bunu aşağıdaki gibi düzeltebilirsiniz:

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

Burada, alt elemanın (1) Iterablebir ABC ile yinelenebilir olup olmadığını kontrol edersiniz itertools, fakat aynı zamanda (2) elemanın "dize benzeri" olmadığından emin olmak istersiniz.

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

Bu Kurallar, listeyi sonuna kadar genişlettiği için de iyi çalışır. Çok benzer olmasına rağmen, sadece döngü için bir tane var. Bu yüzden döngüler için 2 eklemekten daha az karmaşıklığa sahiptir.

from nltk import flatten

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

Bu çözümün diğerlerine göre avantajı şuna benzer bir listeniz varsa:

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

diğer çözümlerin çoğu hata verirken bu çözüm bunları ele alır.

Bu en etkili yol olmayabilir ama bir astar (aslında iki astar) koymayı düşündüm. Her iki sürüm de rasgele hiyerarşi iç içe listelerinde çalışır ve dil özelliklerini (Python3.5) ve özyinelemeyi kullanır.

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)

Çıktı

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

Bu öncelikle derinlemesine çalışır. Özyineleme, liste dışı bir öğe bulana kadar aşağı iner, ardından yerel değişkeni genişletir flistve sonra üst öğeye geri döndürür. Ne zaman flistiade edilirse , flistliste kavrayışında ebeveynin genişletilir . Bu nedenle, kökte düz bir liste döndürülür.

Yukarıdakiler birkaç yerel liste oluşturur ve bu listeyi ebeveyn listesini genişletmek için kullanır. Sanırım bunun için yol flistaşağıdaki gibi bir gloabl yaratmak olabilir .

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)

Çıktı yine

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

Her ne kadar bu konuda verimlilik konusunda emin değilim.

Hetero ve homojen tamsayı listeleri için çalışan bir başka alışılmadık yaklaşım:

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