элементов - Создание списка из списка списков в Python




задачи на списки python (20)

Интересно, есть ли ярлык, чтобы сделать простой список из списка списков в Python.

Я могу сделать это в цикле for, но, может быть, есть классный «однострочный»? Я попробовал его с уменьшением , но я получаю сообщение об ошибке.

Код

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'

Вот общий подход, который применяется к числам , строкам , вложенным спискам и смешанным контейнерам.

Код

from collections import Iterable


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

демонстрация

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

Ссылка

  • Это решение модифицировано из рецепта в Beazley, D. and B. Jones. Рецепт 4.14, Кулинарная книга Python 3rd Ed., O'Reilly Media Inc. Севастополь, Калифорния: 2013.
  • Нашел более ранний пост SO , возможно, оригинальную демонстрацию.

Вы можете использовать itertools.chain() :

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

или, на Python> = 2.6, используйте itertools.chain.from_iterable() который не требует распаковки списка:

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

Этот подход, возможно, более читабельен, чем [item for sublist in l for item in sublist] и, похоже, быстрее:

[[email protected]]$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99;import itertools' 'list(itertools.chain.from_iterable(l))'
10000 loops, best of 3: 24.2 usec per loop
[[email protected]]$ 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: 45.2 usec per loop
[[email protected]]$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' 'sum(l, [])'
1000 loops, best of 3: 488 usec per loop
[[email protected]]$ 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: 522 usec per loop
[[email protected]]$ python --version
Python 2.7.3

Другой необычный подход, который работает для гетеро- и однородных списков целых чисел:

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

Если вы готовы отказаться от небольшого количества скорости для более чистого вида, вы можете использовать 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


Кажется, есть путаница с operator.add ! Когда вы добавляете два списка вместе, правильный термин для этого является concat , а не add. operator.concat - это то, что вам нужно использовать.

Если вы думаете о функциональности, это так же просто, как это:

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

Можно также использовать flat NumPy:

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

Редактировать 11/02/2016: Работает только в том случае, если подписи имеют одинаковые размеры.


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

> pip install more_itertools

Он поставляется с реализацией для flatten ( source , из рецептов 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 ( source , внесенный 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+y, l)

Это должно работать нормально.


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

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

Примечание. Расширение более эффективно, чем + в списках.


Простой код для underscore.py накопителя 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

Следующее кажется мне самым простым:

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

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

list(itertools.chain.from_iterable(a))

быть самым быстрым решением (если конкатенировано более 10 списков).

Код для воспроизведения сюжета:

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 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,
    kernels=[
        forfor, sum_brackets, functools_reduce, itertools_chain, numpy_flat,
        numpy_concatenate
        ],
    n_range=[2**k for k in range(16)],
    logx=True,
    logy=True,
    xlabel='num lists'
    )

Примечание автора : Это неэффективно. Но весело, потому что монады потрясающие. Это не подходит для производственного кода 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] .

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


Примечание . Ниже применимо к 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) итерируется с IterableABC itertools, но также должен гарантировать, что (2) элемент не является «похожим на строку».


Вы можете избежать рекурсивных вызовов в стек с использованием фактической структуры данных стека довольно просто.

alist = [1,[1,2],[1,2,[4,5,6],3, "33"]]
newlist = []

while len(alist) > 0 :
  templist = alist.pop()
  if type(templist) == type(list()) :
    while len(templist) > 0 :
      temp = templist.pop()
      if type(temp) == type(list()) :
        for x in temp :
          templist.append(x)
      else :
        newlist.append(temp)
  else :
    newlist.append(templist)
print(list(reversed(newlist)))

Недавно я столкнулся с ситуацией, когда у меня было сочетание строк и числовых данных в подсписках, таких как

test = ['591212948',
['special', 'assoc', 'of', 'Chicago', 'Jon', 'Doe'],
['Jon'],
['Doe'],
['fl'],
92001,
555555555,
'hello',
['hello2', 'a'],
'b',
['hello33', ['z', 'w'], 'b']]

где такие методы flat_list = [item for sublist in test for item in sublist]не работали. Итак, я придумал следующее решение для 1+ уровней подсписок

def concatList(data):
    results = []
    for rec in data:
        if type(rec) == list:
            results += rec
            results = concatList(results)
        else:
            results.append(rec)
    return results

И результат

In [38]: concatList(test)
Out[38]:
 Out[60]:
['591212948',
'special',
'assoc',
'of',
'Chicago',
'Jon',
'Doe',
'Jon',
'Doe',
'fl',
92001,
555555555,
'hello',
'hello2',
'a',
'b',
'hello33',
'z',
'w',
'b']

Это может быть не самый эффективный способ, но я решил поставить однострочный (фактически двухстрочный). Обе версии будут работать с произвольными иерархическими вложенными списками и использовать функции языка (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]

Хотя я не уверен в это время об эффективности.


def flatten(alist):
    if alist == []:
        return []
    elif type(alist) is not list:
        return [alist]
    else:
        return flatten(alist[0]) + flatten(alist[1:])

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

Этот код также отлично работает, так как он просто расширяет список. Хотя это очень похоже, но только для цикла. Таким образом, он имеет меньшую сложность, чем добавление 2 для циклов.


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

что значит:

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 sublists - поскольку промежуточный список результатов продолжает увеличиваться, на каждом шаге появляется новый промежуточный результат список объектов распределяется, и все элементы предыдущего промежуточного результата должны быть скопированы (а также несколько новых добавленных в конце). Таким образом (для простоты и без фактической потери общности) скажем, что у вас есть L подсписок из I предметов каждый: первые предметы I копируются взад и вперед L-1 раз, второй I - L-2 раза и т. Д .; общее количество копий I умножает сумму x для x от 1 до L, т. е. I * (L**2)/2 .

Понимание списка просто генерирует один список, один раз и копирует каждый элемент (от его первоначального места жительства до списка результатов) также ровно один раз.





flatten