Gostaria de saber se existe um atalho para fazer uma lista simples fora da lista de listas em Python.

Eu posso fazer isso em um forloop, mas talvez haja algum "one-liner" legal? Eu tentei reduce(), mas recebo um erro.

Código

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

Mensagem de erro

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

Dada uma lista de listas l,

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

que significa:

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

é mais rápido que os atalhos publicados até o momento. ( lé a lista para achatar.)

Aqui está a função correspondente:

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

Como evidência, você pode usar o timeitmódulo na biblioteca padrão:

$ 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

Explicação: os atalhos baseados em + (incluindo o uso implícito em sum) são, necessariamente, O(L**2)quando existem L sublistas - como a lista de resultados intermediários fica cada vez mais longa, a cada etapa um novo objeto da lista de resultados intermediários é alocado e todos os itens no resultado intermediário anterior deve ser copiado (assim como alguns novos adicionados no final). Portanto, por simplicidade e sem perda real de generalidade, digamos que você tenha L sublistas de itens I cada: os primeiros itens I são copiados para frente e para trás L-1 vezes, o segundo I itens L-2 vezes e assim por diante; o número total de cópias é I vezes a soma de x para x de 1 a L excluída, ou seja I * (L**2)/2,.

A compreensão da lista gera apenas uma lista, uma vez, e copia cada item (do local de residência original para a lista de resultados) também exatamente uma vez.

Você pode usar itertools.chain():

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

Ou você pode usar o itertools.chain.from_iterable()que não requer descompactar a lista com o *operador :

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

Nota do autor : Isso é ineficiente. Mas divertido, porque os monoides são incríveis. Não é apropriado para o código Python de produção.

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

Isso apenas soma os elementos de iterável passados ​​no primeiro argumento, tratando o segundo argumento como o valor inicial da soma (se não for fornecido, 0é usado em seu lugar e, neste caso, ocorrerá um erro).

Como você está somando listas aninhadas, na verdade você obtém o [1,3]+[2,4]resultado de sum([[1,3],[2,4]],[]), que é igual a[1,3,2,4] .

Observe que funciona apenas em listas de listas. Para listas de listas de listas, você precisará de outra solução.

Testei as soluções mais sugeridas com perfplot (um projeto para animais de estimação, essencialmente um invólucro timeit) e descobri

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

para ser a solução mais rápida, quando muitas listas pequenas e poucas listas longas são concatenadas. ( operator.iaddé igualmente rápido.)

Código para reproduzir o gráfico:

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]

O extend()método no seu exemplo modifica, em xvez de retornar um valor útil (quereduce() espera).

Uma maneira mais rápida de fazer a reduceversão seria

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

Não reinvente a roda se você usar o Django :

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

... Pandas :

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

... Ferramentas :

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

... Setuptools :

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

Aqui está uma abordagem geral que se aplica a números , seqüências de caracteres , listas aninhadas e contêineres mistos .

Código

#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

Notas :

• No Python 3, yield from flatten(x)pode substituirfor sub_x in flatten(x): yield sub_x
• Em Python 3,8, classes base sumário são movidos a partir de collection.abcpara o typingmódulo.

Demo

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

Referência

• Esta solução é modificada de uma receita em Beazley, D. e B. Jones. Receita 4.14, Python Cookbook 3rd Ed., O'Reilly Media Inc. Sebastopol, CA: 2013.
• Encontrei um post anterior do SO , possivelmente a demonstração original.

Se você deseja achatar uma estrutura de dados em que não sabe o quão profundo está aninhado, você pode usar ¹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]

É um gerador, então você precisa converter o resultado em listou iterar explicitamente sobre ele.

Para nivelar apenas um nível e se cada um dos itens for iterável, você também poderá usar o iteration_utilities.flattenque é apenas um invólucro fino 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]

Apenas para adicionar alguns horários (com base na resposta de Nico Schlömer que não incluiu a função apresentada nesta resposta):

É um gráfico de log-log para acomodar a enorme variedade de valores estendidos. Para raciocínio qualitativo: quanto mais baixo, melhor.

Os resultados mostram que se o iterable contém apenas alguns iterables internas, em seguida, sumserá mais rápido, no entanto por longos iterables única as itertools.chain.from_iterable, iteration_utilities.deepflattenou a compreensão aninhada ter um desempenho razoável com itertools.chain.from_iterablesendo o mais rápido (como já foi observado por 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 Isenção de responsabilidade: eu sou o autor dessa biblioteca}

Eu retiro minha declaração. soma não é o vencedor. Embora seja mais rápido quando a lista é pequena. Mas o desempenho diminui significativamente com listas maiores.

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

A versão sum ainda está em execução por mais de um minuto e ainda não foi processada!

Para listas médias:

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

Usando listas pequenas e timeit: 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

Parece haver uma confusão com operator.add! Quando você adiciona duas listas, o termo correto para isso é concatnão adicionar. operator.concaté o que você precisa usar.

Se você está pensando funcional, é tão fácil quanto isso ::

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

Você vê reduzir os aspectos do tipo de sequência; portanto, quando você fornece uma tupla, recebe uma tupla. Vamos tentar com uma lista:

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

Aha, você volta a lista.

Como sobre o desempenho ::

>>> 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é bem rápido! Mas não há comparação com a qual reduzir 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

Por que você usa estender?

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

Isso deve funcionar bem.

Considere instalar o more_itertoolspacote.

> pip install more_itertools

É fornecido com uma implementação para flatten( fonte , das receitas do 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]

A partir da versão 2.4, você pode nivelar iteráveis aninhados mais complicados com more_itertools.collapse( fonte , contribuído por 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]

A razão pela qual sua função não funcionou é porque a extensão estende uma matriz no local e não a retorna. Você ainda pode retornar x do lambda, usando algo como isto:

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

Nota: estender é mais eficiente que + nas listas.

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]

Versão recursiva

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() funcionará para listas aninhadas, mesmo que elas se aninhem mais profundamente que o exemplo.

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

Resultado:

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

Isso é 18x mais rápido que o sublinhado ._. 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

A resposta aceita não funcionou para mim ao lidar com listas de tamanho variável de textos. Aqui está uma abordagem alternativa que funcionou para mim.

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

Resposta aceita que não funcionou:

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

Nova solução que propôs fez trabalho para mim:

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

Uma característica ruim da função do Anil acima é que ele exige que o usuário sempre especifique manualmente o segundo argumento como uma lista vazia [] . Em vez disso, isso deve ser um padrão. Devido à maneira como os objetos Python funcionam, eles devem ser definidos dentro da função, não nos argumentos.

Aqui está uma função de trabalho:

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

Teste:

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 seguir, parece-me mais simples:

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

Pode-se também usar o apartamento do NumPy :

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

Editar 11/02/2016: Funciona apenas quando sublistas têm dimensões idênticas.

Você pode usar numpy:
flat_list = list(np.concatenate(list_of_list))

Se você estiver disposto a abrir uma pequena quantidade de velocidade para obter uma aparência mais limpa, poderá usar numpy.concatenate().tolist()ou 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

Você pode descobrir mais aqui nos documentos numpy.concatenate e numpy.ravel

Solução mais rápida que encontrei (para lista grande de qualquer maneira):

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

Feito! Obviamente, você pode transformá-lo novamente em uma lista executando a lista (l)

Código simples para o underscore.pyventilador do pacote

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

Resolve todos os problemas de nivelamento (nenhum item da lista ou aninhamento complexo)

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]

Você pode instalar underscore.pycom 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:])

Nota : Abaixo se aplica ao Python 3.3+ porque ele usa yield_from. sixtambém é um pacote de terceiros, embora seja estável. Como alternativa, você pode usarsys.version .

No caso de obj = [[1, 2,], [3, 4], [5, 6]], todas as soluções aqui são boas, incluindo compreensão de lista eitertools.chain.from_iterable .

No entanto, considere este caso um pouco mais complexo:

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

Existem vários problemas aqui:

• Um elemento 6 ,, é apenas um escalar; não é iterável; portanto, as rotas acima falharão aqui.
• Um elemento, 'abc', é tecnicamente iterable (todosstr s são). No entanto, lendo um pouco as entrelinhas, você não deseja tratá-lo como tal - você deseja tratá-lo como um único elemento.
• O elemento final [8, [9, 10]]é ele próprio um iterável aninhado. Compreensão básica da lista e chain.from_iterableextraia apenas "1 nível abaixo".

Você pode corrigir isso da seguinte maneira:

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

Aqui, você verifica se o subelemento (1) é iterável com Iterableum ABC de itertools, mas também deseja garantir que (2) o elemento não seja "semelhante a uma string".

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

Este código também funciona bem, pois apenas estende a lista até o fim. Embora seja muito parecido, mas só tem um para loop. Portanto, ele tem menos complexidade do que adicionar 2 para loops.

from nltk import flatten

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

A vantagem desta solução sobre a maioria das outras aqui é que, se você tiver uma lista como:

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

enquanto a maioria das outras soluções gera um erro, esta solução lida com elas.

Esta pode não ser a maneira mais eficiente, mas pensei em colocar uma linha (na verdade, uma linha). Ambas as versões funcionarão em listas aninhadas na hierarquia arbitrária e explorarão os recursos da linguagem (Python3.5) e a recursão.

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)

A saída é

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

Isso funciona de maneira profunda e profunda. A recursão diminui até encontrar um elemento que não seja da lista, estende a variável local fliste a reverte para o pai. Sempre que flisté retornado, ele é estendido aosflist na compreensão da lista. Portanto, na raiz, uma lista simples é retornada.

A lista acima cria várias listas locais e as retorna, que são usadas para estender a lista dos pais. Eu acho que o caminho para isso pode estar criando um gloabl flist, como abaixo.

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)

A saída é novamente

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

Embora não tenha certeza no momento sobre a eficiência.

Outra abordagem incomum que funciona para listas hetero e homogêneas de números inteiros:

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