Преобразование многомерного списка в 1D-список в Python

Question

Многомерный список, например l=[[1,2],[3,4]], может быть преобразован в 1D, выполнив sum(l,[]). Может ли кто-нибудь объяснить, как это происходит?

Ответчик сказал, что этот метод можно использовать только для «сглаживания» 2D-списка - что он не будет работать для более высоких многомерных списков. Но это происходит, если повторять. Например, если A является 3D-списком, тогда сумма (сумма (A), []), []) сгладит A до 1D-списка.

Answer 1

sum добавляет последовательность вместе с использованием оператора +. например, sum([1,2,3]) == 6. Второй параметр является необязательным начальным значением, которое по умолчанию равно 0. например. sum([1,2,3], 10) == 16.

В вашем примере это [] + [1,2] + [3,4], где + в 2 списках объединяет их вместе. Поэтому результат [1,2,3,4]

Пустой список требуется в качестве 2-го параметра Я к sum, потому что, как уже упоминалось выше, по умолчанию для sum добавить в 0 (т.е. 0 + [1,2] + [3,4]), что приведет к неподдерживаемый тип операнда (s) для +: 'Int' и 'список'

Это соответствующий раздел помощи для sum:

сумма (последовательность [, начало]) -> значение

Возвращает сумму последовательности номеров (НЕ строки) плюс значение параметра 'start' (по умолчанию - 0).

Примечание

Как wallacoloo comented это не общее решение для выпрямления любого многомерные списка. Он просто работает для списка 1D-списков из-за поведения, описанного выше.

Update

На пути к сплющить 1 уровень вложенности см этот рецепт от itertools страницы:

def flatten(listOfLists): 
    "Flatten one level of nesting" 
    return chain.from_iterable(listOfLists) 

сглаживаться более глубоко вложенной списки (в том числе неправильно вложенных списков) см accepted answer до this question (есть и другие вопросы, связанные с этим вопросом.)

Обратите внимание, что в рецепте возвращается номер itertools.chain (итерабельный), а ответ другого вопроса возвращает объект generator, поэтому вам нужно обернуть любой из них при вызове list, если вам нужен полный список, а не итерация по нему. например list(flatten(my_list_of_lists)).

Answer 2

Она смотрит на меня больше как вы ищете для окончательного ответа:

[3, 7] 

За что ты лучше от с list comprehension

>>> l=[[1,2],[3,4]] 
>>> [x+y for x,y in l] 
[3, 7] 

Answer 3

Если список nested есть, как вы говорите, «2D» (это означает, что вы хотите идти только на один уровень вниз, а все позиции с 1 уровнем вниз из nested - это списки), простое понимание списка:

flat = [x for sublist in nested for x in sublist] 

является подход, который я рекомендовал бы - гораздо эффективнее, чем sum мина будет (sum предназначен для чисел - это было просто слишком много потрудился как-то сделать его блокировать все попытки «сумма» non-numbers ... Я был оригинальным автором и первым разработчиком sum в стандартной библиотеке Python, поэтому, я думаю, я должен знать ;-).

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

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

Answer 4

Я написал программу для многомерного сплющивания с использованием рекурсии. Если у кого есть замечания по делает программу лучше, вы всегда можете видеть меня улыбаться:

def flatten(l): 
    lf=[] 
    li=[] 
    ll=[] 
    p=0 
    for i in l: 
     if type(i).__name__=='list': 
      li.append(i) 
     else: 
      lf.append(i) 
    ll=[x for i in li for x in i] 
    lf.extend(ll) 

    for i in lf: 
     if type(i).__name__ =='list': 
      #not completely flattened 
      flatten(lf) 
     else: 
      p=p+1 
      continue 

    if p==len(lf): 
     print(lf) 

Answer 5

Для любого вида multidiamentional массива, этот код будет делать уплощение в одном измерении:

def flatten(l): 
    try: 
     return flatten(l[0]) + (flatten(l[1:]) if len(l) > 1 else []) if type(l) is list else [l] 
    except IndexError: 
     return [] 

Answer 6

Оператор + объединяет списки, а начальное значение [] - пустой список.