Как спрятать hetrogenous список списка в один список в python?

У меня есть список объектов, где объектами могут быть списки или скаляры. Я хочу сплющенный список только с скалярами. Например:

L = [35,53,[525,6743],64,63,[743,754,757]] outputList = [35,53,525,6743,64,63,743,754,757] 

PS Ответы в этом вопросе не работают для гетерогенных списков. Сглаживание мелкого списка в Python

    Вот относительно простая рекурсивная версия, которая будет сглаживать любую глубину списка

     l = [35,53,[525,6743],64,63,[743,754,757]] def flatten(xs): result = [] if isinstance(xs, (list, tuple)): for x in xs: result.extend(flatten(x)) else: result.append(xs) return result print flatten(l) 

    это можно сделать аккуратно в одной строке, используя numpy

     import numpy as np np.hstack(l) 

    вы закончите с ndarray

     array([ 35, 53, 525, 6743, 64, 63, 743, 754, 757]) 
     >>> data = [35,53,[525,6743],64,63,[743,754,757]] >>> def flatten(L): for item in L: if isinstance(item,list): for subitem in item: yield subitem else: yield item >>> list(flatten(data)) [35, 53, 525, 6743, 64, 63, 743, 754, 757] 

    Вот однострочная версия для целей кодирования кода (это выглядит не очень хорошо: D)

     >>> [y for x in data for y in (x if isinstance(x,list) else [x])] [35, 53, 525, 6743, 64, 63, 743, 754, 757] 
     l = [35,53,[525,6743],64,63,[743,754,757]] outputList = [] for i in l: if isinstance(i, list): outputList.extend(i) else: outputList.append(i) 

    Вот онлайнер, основанный на вопросе, который вы упомянули :

     list(itertools.chain(*((sl if isinstance(sl, list) else [sl]) for sl in l))) 

    ОБНОВЛЕНИЕ: И полностью итераторная версия:

     from itertools import imap, chain list(chain.from_iterable(imap(lambda x: x if isinstance(x, list) else [x], l))) 
     outputList = [] for e in l: if type(e) == list: outputList += e else: outputList.append(e) >>> outputList [35, 53, 525, 6743, 64, 63, 743, 754, 757] 
     def nchain(iterable): for elem in iterable: if type(elem) is list: for elem2 in elem: yield elem2 else: yield elem 

    Рекурсивная функция, которая позволит бесконечную глубину дерева:

     def flatten(l): if isinstance(l,(list,tuple)): if len(l): return flatten(l[0]) + flatten(l[1:]) return [] else: return [l] >>>flatten([35,53,[525,[1,2],6743],64,63,[743,754,757]]) [35, 53, 525, 1, 2, 6743, 64, 63, 743, 754, 757] 

    Я попытался избежать isinstance, чтобы разрешить общие типы, но старая версия будет бесконечным циклом на строках. Теперь он правильно выравнивает строки (теперь не по символам, а как будто он притворяется, что строка является скаляром).

     >>> L = [35,53,[525,6743],64,63,[743,754,757]] >>> K = [] >>> [K.extend([i]) if type(i) == int else K.extend(i) for i in L ] [None, None, None, None, None, None] >>> K [35, 53, 525, 6743, 64, 63, 743, 754, 757] 

    Это решение предназначено только для конкретной ситуации (скаляры в списках) и предполагает, что скаляры являются целыми. Это ужасное решение, но оно невероятно короткое.

     outputlist = map(int,",".split(str(L).replace("[","").replace("]",""))) 

    Ответ довольно прост! Воспользуйтесь рекурсией.

     def flatten(nst_lst, final_list): for val in nst_lst: if isinstance(val, list): flatten(val, final_list) else: final_list.append(val) return final_list #Sample usage fl_list = [] lst_to_flatten = [["this",["a",["thing"],"a"],"is"],["a","easy"]] print(flatten(lst_to_flatten, fl_list))