Цікаво, чи є ярлик, щоб зробити простий список зі списку списків на Python.

Я можу це зробити в forциклі, але, можливо, є якийсь крутий "однолінійний"? Я спробував це reduce(), але я отримую помилку.

Код

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

Повідомлення про помилку

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

Враховуючи список списків 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це список для вирівнювання.)

Ось відповідна функція:

flatten = lambda l: [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: кожен перший пункт I копіюється L-1 раз, другий I - L-2 рази тощо; загальна кількість примірників в I разів перевищує суму x для x від 1 до L, виключається, тобто I * (L**2)/2.

Зрозуміння списку просто генерує один список один раз і копіює кожен елемент (від його початкового місця проживання до списку результатів) також рівно один раз.

Ви можете використовувати itertools.chain():

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

Або ви можете використовувати те, itertools.chain.from_iterable()що не потребує розпакування списку з *оператором :

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

Примітка автора : Це неефективно. Але весело, бо моноїди - приголомшливі. Це не підходить для виробництва Python-коду.

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

Це просто підсумовує елементи ітерабельного переданого в першому аргументі, трактуючи другий аргумент як початкове значення суми (якщо він не вказаний, 0використовується замість цього, і цей випадок приведе до помилки)

Оскільки ви підсумовуєте вкладені списки, ви насправді отримуєте [1,3]+[2,4]результат sum([[1,3],[2,4]],[]), який дорівнює [1,3,2,4].

Зауважте, що працює лише у списках списків. Для списків списків списків вам знадобиться інше рішення.

Я протестував більшість запропонованих рішень з perfplot (мій проект для домашніх тварин, по суті, обгортка timeit), і знайшов

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

бути найшвидшим рішенням, як об'єднано багато невеликих списків, так і декілька довгих списків. ( operator.iaddоднаково швидко.)

Код для відтворення сюжету:

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()Метод в вашому прикладі модифікує xзамість повернення корисного значення (яке reduce()очікує).

Швидший спосіб зробити reduceверсію був би

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

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

... Панди :

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

... Itertools :

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

... Матплотліб

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

... Unipath :

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

... Налаштування :

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

Ось загальний підхід, який застосовується до чисел , рядків , вкладених списків та змішаних контейнерів.

Код

#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

Примітки :

• У Python 3 yield from flatten(x) можна замінитиfor sub_x in flatten(x): yield sub_x
• В Python 3.8, абстрактні базові класи будуть переміщені з collection.abcдо typingмодулю.

Демо

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

Довідково

• Це рішення модифіковане з рецепту в Бізлі, Д. та Б. Джонса. Рецепт 4.14, кулінарна книга Python, 3-е видання, O'Reilly Media Inc. Севастополь, Каліфорнія: 2013.
• Знайдено більш ранню публікацію SO , можливо, оригінальну демонстрацію.

Якщо ви хочете вирівняти структуру даних, де ви не знаєте, наскільки глибоко це вкладено, ви можете використовувати ¹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]

Це генератор, тому потрібно передавати результат на listабо явно повторювати його.

Щоб вирівняти лише один рівень, і якщо кожен із предметів є ітерабельним, ви також можете використовувати iteration_utilities.flattenякий-небудь лише тонку обгортку навколо 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]

Просто для додання декількох моментів (на основі відповіді Ніко Шльомера, яка не включала функцію, представлену у цій відповіді):

Це графік журналу журналу для розміщення величезного діапазону значень. Для якісного міркування: краще нижче.

Результати показують , що якщо итератор містить лише кілька внутрішніх ітеріруемие тоді sumбуде швидким, проте в протягом тривалих ітеріруемих тільки в itertools.chain.from_iterable, iteration_utilities.deepflattenабо вкладені розуміннях мають достатню продуктивність при itertools.chain.from_iterableнайшвидшому (як уже помітив Ніко 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 Відмова: Я автор цієї бібліотеки}

Я повертаю свою заяву назад. сума не є переможцем. Хоча це швидше, коли список невеликий. Але продуктивність значно погіршується при більших списках.

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

Сума версії все ще працює більше хвилини, і вона ще не виконана обробка!

Для середніх списків:

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

Використання невеликих списків та timeit: число = 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

Здається, плутанина з operator.add! Коли ви додаєте два списки разом, правильний термін для цього є concat, а не додавати. operator.concatце те, що вам потрібно використовувати.

Якщо ви думаєте функціонально, це так просто, як це:

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

Ви бачите, що скорочення поважає тип послідовності, тож коли ви постачаєте кортеж, ви отримуєте назад кортеж. Спробуємо зі списком ::

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

Ага, ти повертаєш список.

Як щодо продуктивності ::

>>> 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_iterableдосить швидко! Але це порівняння не зводиться 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

Для чого ви використовуєте розширення?

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

Це має добре працювати.

Подумайте про встановлення more_itertoolsпакета.

> pip install more_itertools

Він постачається з реалізацією для flatten( джерело , з рецептів 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]

З версії 2.4 ви можете згладити більш складні, вкладені ітерабелі more_itertools.collapse( джерело , внесене 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]

Причина, по якій ваша функція не працювала, полягає в тому, що розширення розширює масив на місці і не повертає його. Ви все ще можете повернути х з лямбда, використовуючи щось подібне:

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

Примітка: розширення є більш ефективним, ніж + у списках.

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]

Рекурсивна версія

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() буде працювати для вкладених списків, навіть якщо вони вкладаються глибше, ніж приклад.

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

Прийнята відповідь не працювала для мене при роботі із текстовими списками змінної довжини. Ось альтернативний підхід, який спрацював для мене.

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

Прийнята відповідь, яка не спрацювала:

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

Нові запропоновані рішення , які зробили роботу для мене:

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

Погана особливість функції Аніла вище полягає в тому, що вона вимагає від користувача завжди вручну вказувати, що другий аргумент є порожнім списком []. Натомість це має бути за замовчуванням. Завдяки тому, як працюють об’єкти Python, їх слід встановлювати всередині функції, а не в аргументах.

Ось робоча функція:

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

Тестування:

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]

Наступні здаються мені найпростішими:

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

Можна також використовувати квартиру NumPy :

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

Редагувати 02.02.2016: Працює лише тоді, коли сублісти мають однакові розміри.

Ви можете використовувати numpy:
flat_list = list(np.concatenate(list_of_list))

Якщо ви готові відмовитися від невеликої кількості швидкостей для більш чистого вигляду, тоді ви можете скористатися 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

Найшвидше я знайшов рішення (все-таки для великого списку):

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

Готово! Звичайно, ви можете повернути його до списку, виконавши список (l)

Простий код для underscore.pyвентилятора упаковки

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

Він вирішує всі згладжені проблеми (жоден елемент списку чи складне гніздування)

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.pyдопомогою 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:])

Примітка : Нижче стосується Python 3.3+, оскільки він використовується yield_from. 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' , є технічно итерацией (всеstr з є). Однак трохи читаючи між рядками, ви не хочете трактувати його як таке - ви хочете трактувати його як єдиний елемент.
• Заключний елемент, [8, [9, 10]]сам по собі є вкладеним ітерабельним. Основне розуміння списку і chain.from_iterableлише витяг "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) є ітерабельним Iterable, з ABC від itertools, але також хочете переконатися, що (2) елемент не є "схожим на рядок".

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

Цей Кодекс також добре працює, оскільки він просто розширює список. Хоча вона дуже схожа, але є лише одна для циклу. Отже, вона має меншу складність, ніж додавання 2 для циклів.

from nltk import flatten

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

Перевага цього рішення перед більшістю інших у тому, що якщо у вас є такий список, як:

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

в той час як більшість інших рішень помиляються, це рішення обробляє їх.

Це може бути не найефективнішим способом, але я подумав поставити однолінійку (насправді двоконтурний). Обидві версії працюватимуть за довільною ієрархією вкладених списків та використовують мовні особливості (Python3.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]

Хоча наразі я не впевнений у ефективності.

Ще один незвичний підхід, який працює для гетеро- та однорідних списків цілих чисел:

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