Вирівняти неправильний список списків

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

L = [[[1, 2, 3], [4, 5]], 6]

Де потрібний вихід

[1, 2, 3, 4, 5, 6]

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

def flatten(x):
    result = []
    for el in x:
        if hasattr(el, "__iter__") and not isinstance(el, basestring):
            result.extend(flatten(el))
        else:
            result.append(el)
    return result

flatten(L)

Це найкраща модель? Я щось пропустив? Якісь проблеми?

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

Пітон 2

def flatten(l):
    for el in l:
        if isinstance(el, collections.Iterable) and not isinstance(el, basestring):
            for sub in flatten(el):
                yield sub
        else:
            yield el

Я використав Iterable ABC, доданий у 2.6.

Пітон 3

У Python 3 basestringбільше немає, але ви можете використовувати кортеж strта bytesотримати той же ефект там.

yield fromОператор повертає елемент з генератора по одному. Цей синтаксис для делегування до підгенератора додано в 3.3

def flatten(l):
    for el in l:
        if isinstance(el, collections.Iterable) and not isinstance(el, (str, bytes)):
            yield from flatten(el)
        else:
            yield el

Моє рішення:

import collections


def flatten(x):
    if isinstance(x, collections.Iterable):
        return [a for i in x for a in flatten(i)]
    else:
        return [x]

Трохи більш лаконічно, але майже те саме.

Генератор за допомогою рекурсії та набору качок (оновлено для Python 3):

def flatten(L):
    for item in L:
        try:
            yield from flatten(item)
        except TypeError:
            yield item

list(flatten([[[1, 2, 3], [4, 5]], 6]))
>>>[1, 2, 3, 4, 5, 6]

Версія генератора нерекурсивного рішення @ unutbu, як вимагає @Andrew у коментарі:

def genflat(l, ltypes=collections.Sequence):
    l = list(l)
    i = 0
    while i < len(l):
        while isinstance(l[i], ltypes):
            if not l[i]:
                l.pop(i)
                i -= 1
                break
            else:
                l[i:i + 1] = l[i]
        yield l[i]
        i += 1

Трохи спрощена версія цього генератора:

def genflat(l, ltypes=collections.Sequence):
    l = list(l)
    while l:
        while l and isinstance(l[0], ltypes):
            l[0:1] = l[0]
        if l: yield l.pop(0)

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

flatten = lambda *n: (e for a in n
    for e in (flatten(*a) if isinstance(a, (tuple, list)) else (a,)))

Використання:

l1 = ['a', ['b', ('c', 'd')]]
l2 = [0, 1, (2, 3), [[4, 5, (6, 7, (8,), [9]), 10]], (11,)]
print list(flatten(l1, -2, -1, l2))
['a', 'b', 'c', 'd', -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

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

import itertools as IT
import collections

def flatten(iterable, ltypes=collections.Iterable):
    remainder = iter(iterable)
    while True:
        first = next(remainder)
        if isinstance(first, ltypes) and not isinstance(first, (str, bytes)):
            remainder = IT.chain(first, remainder)
        else:
            yield first

Ось кілька прикладів, що демонструють його використання:

print(list(IT.islice(flatten(IT.repeat(1)),10)))
# [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

print(list(IT.islice(flatten(IT.chain(IT.repeat(2,3),
                                       {10,20,30},
                                       'foo bar'.split(),
                                       IT.repeat(1),)),10)))
# [2, 2, 2, 10, 20, 30, 'foo', 'bar', 1, 1]

print(list(flatten([[1,2,[3,4]]])))
# [1, 2, 3, 4]

seq = ([[chr(i),chr(i-32)] for i in range(ord('a'), ord('z')+1)] + list(range(0,9)))
print(list(flatten(seq)))
# ['a', 'A', 'b', 'B', 'c', 'C', 'd', 'D', 'e', 'E', 'f', 'F', 'g', 'G', 'h', 'H',
# 'i', 'I', 'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N', 'o', 'O', 'p', 'P',
# 'q', 'Q', 'r', 'R', 's', 'S', 't', 'T', 'u', 'U', 'v', 'V', 'w', 'W', 'x', 'X',
# 'y', 'Y', 'z', 'Z', 0, 1, 2, 3, 4, 5, 6, 7, 8]

Хоча flattenможе працювати з нескінченними генераторами, він не може впоратися з нескінченними гніздуваннями:

def infinitely_nested():
    while True:
        yield IT.chain(infinitely_nested(), IT.repeat(1))

print(list(IT.islice(flatten(infinitely_nested()), 10)))
# hangs

Ось ще одна відповідь, яка ще цікавіша ...

import re

def Flatten(TheList):
    a = str(TheList)
    b,crap = re.subn(r'[\[,\]]', ' ', a)
    c = b.split()
    d = [int(x) for x in c]

    return(d)

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

def flatten(xs):
    res = []
    def loop(ys):
        for i in ys:
            if isinstance(i, list):
                loop(i)
            else:
                res.append(i)
    loop(xs)
    return res

Ви можете використовувати deepflattenз сторонніх пакетів iteration_utilities:

>>> from iteration_utilities import deepflatten
>>> L = [[[1, 2, 3], [4, 5]], 6]
>>> list(deepflatten(L))
[1, 2, 3, 4, 5, 6]

>>> list(deepflatten(L, types=list))  # only flatten "inner" lists
[1, 2, 3, 4, 5, 6]

Це ітератор, тому його потрібно повторити (наприклад, загорнувши його listабо скориставшись циклом). Внутрішньо він використовує ітеративний підхід замість рекурсивного підходу, і він записується як розширення C, щоб він був швидшим, ніж чистий підхід python:

>>> %timeit list(deepflatten(L))
12.6 µs ± 298 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
>>> %timeit list(deepflatten(L, types=list))
8.7 µs ± 139 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

>>> %timeit list(flatten(L))   # Cristian - Python 3.x approach from https://stackoverflow.com/a/2158532/5393381
86.4 µs ± 4.42 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

>>> %timeit list(flatten(L))   # Josh Lee - https://stackoverflow.com/a/2158522/5393381
107 µs ± 2.99 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

>>> %timeit list(genflat(L, list))  # Alex Martelli - https://stackoverflow.com/a/2159079/5393381
23.1 µs ± 710 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

Я автор iteration_utilitiesбібліотеки.

Було цікаво намагатися створити функцію, яка могла б вирівняти нерегулярний список у Python, але, звичайно, саме для цього і є Python (щоб програмувати було цікаво). Наступний генератор працює досить добре з деякими застереженнями:

def flatten(iterable):
    try:
        for item in iterable:
            yield from flatten(item)
    except TypeError:
        yield iterable

Це буде вирівнюватися типи даних , які ви можете залишити в спокої (як bytearray, bytesі strоб'єкти). Також код покладається на той факт, що запит ітератора від неітерабельного піднімає a TypeError.

>>> L = [[[1, 2, 3], [4, 5]], 6]
>>> def flatten(iterable):
    try:
        for item in iterable:
            yield from flatten(item)
    except TypeError:
        yield iterable


>>> list(flatten(L))
[1, 2, 3, 4, 5, 6]
>>>

Редагувати:

Я не згоден з попередньою реалізацією. Проблема полягає в тому, що ви не повинні мати можливість вирівняти щось, що не є ітерабельним. Це заплутано і справляє неправильне враження аргументу.

>>> list(flatten(123))
[123]
>>>

Наступний генератор майже такий самий, як перший, але у нього немає проблеми намагатися згладити об'єкт, який не можна повторити. Він не вдається, як можна було б очікувати, якщо йому буде надано невідповідний аргумент.

def flatten(iterable):
    for item in iterable:
        try:
            yield from flatten(item)
        except TypeError:
            yield item

Тестування генератора працює добре зі списком, який було надано. Однак новий код підніме a, TypeErrorколи йому буде надано об'єкт, який не можна повторити. Нижче наведено приклад нової поведінки.

>>> L = [[[1, 2, 3], [4, 5]], 6]
>>> list(flatten(L))
[1, 2, 3, 4, 5, 6]
>>> list(flatten(123))
Traceback (most recent call last):
  File "<pyshell#32>", line 1, in <module>
    list(flatten(123))
  File "<pyshell#27>", line 2, in flatten
    for item in iterable:
TypeError: 'int' object is not iterable
>>>

Хоча було обрано елегантну та дуже пітонічну відповідь, я би представив своє рішення саме для огляду:

def flat(l):
    ret = []
    for i in l:
        if isinstance(i, list) or isinstance(i, tuple):
            ret.extend(flat(i))
        else:
            ret.append(i)
    return ret

Скажіть, будь ласка, наскільки хороший чи поганий цей код?

Я віддаю перевагу прості відповіді. Немає генераторів. Немає обмежень щодо рекурсії чи рекурсії. Просто ітерація:

def flatten(TheList):
    listIsNested = True

    while listIsNested:                 #outer loop
        keepChecking = False
        Temp = []

        for element in TheList:         #inner loop
            if isinstance(element,list):
                Temp.extend(element)
                keepChecking = True
            else:
                Temp.append(element)

        listIsNested = keepChecking     #determine if outer loop exits
        TheList = Temp[:]

    return TheList

Це працює з двома списками: внутрішнім для циклу та зовнішнім циклом while.

Внутрішня для циклу проходить через список. Якщо він знаходить елемент списку, він (1) використовує list.extend () для вирівнювання цієї частини першого рівня вкладення та (2) перемикання KeepChecking на True. Проведення контрольної перевірки використовується для керування зовнішньою петлею. Якщо зовнішня петля встановлена ​​на істинну, вона запускає внутрішню петлю для іншого проходу.

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

Потім сплющений список повертається.

Тестовий запуск

flatten([1,2,3,4,[100,200,300,[1000,2000,3000]]])

[1, 2, 3, 4, 100, 200, 300, 1000, 2000, 3000]

Ось проста функція, яка вирівнює списки довільної глибини. Без рекурсії, щоб уникнути переповнення стека.

from copy import deepcopy

def flatten_list(nested_list):
    """Flatten an arbitrarily nested list, without recursion (to avoid
    stack overflows). Returns a new list, the original list is unchanged.

    >> list(flatten_list([1, 2, 3, [4], [], [[[[[[[[[5]]]]]]]]]]))
    [1, 2, 3, 4, 5]
    >> list(flatten_list([[1, 2], 3]))
    [1, 2, 3]

    """
    nested_list = deepcopy(nested_list)

    while nested_list:
        sublist = nested_list.pop(0)

        if isinstance(sublist, list):
            nested_list = sublist + nested_list
        else:
            yield sublist

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

import re

L = [[[1, 2, 3], [4, 5]], 6]
flattened_list = re.sub("[\[\]]", "", str(L)).replace(" ", "").split(",")
new_list = list(map(int, flattened_list))
print(new_list)

вихід:

[1, 2, 3, 4, 5, 6]

Я не переглянув усі вже доступні відповіді тут, але ось один вкладиш, який я придумав, запозичив у Lisp спосіб першої та решти списку відпочинку

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

ось один простий і один не дуже простий випадок -

>>> flatten([1,[2,3],4])
[1, 2, 3, 4]

>>> flatten([1, [2, 3], 4, [5, [6, {'name': 'some_name', 'age':30}, 7]], [8, 9, [10, [11, [12, [13, {'some', 'set'}, 14, [15, 'some_string'], 16], 17, 18], 19], 20], 21, 22, [23, 24], 25], 26, 27, 28, 29, 30])
[1, 2, 3, 4, 5, 6, {'age': 30, 'name': 'some_name'}, 7, 8, 9, 10, 11, 12, 13, set(['set', 'some']), 14, 15, 'some_string', 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
>>> 

Намагаючись відповісти на таке запитання, вам дійсно потрібно вказати обмеження коду, який ви пропонуєте як рішення. Якби мова йшла лише про виступи, я б не заперечував надто багато, але більшість кодів, запропонованих як рішення (включаючи прийняту відповідь), не змогли сплостити жоден список, глибина якого перевищує 1000.

Коли я кажу більшість кодів я маю на увазі всі коди, які використовують будь-яку форму рекурсії (або називають стандартну функцію бібліотеки, яка є рекурсивною). Усі ці коди виходять з ладу, оскільки для кожного здійсненого рекурсивного виклику стек (виклик) зростає на одну одиницю, а стек виклику (за замовчуванням) пітона має розмір 1000.

Якщо ви не надто знайомі зі стеком викликів, можливо, допоможе наступне (інакше ви можете просто прокрутити до реалізації ).

Розмір стека викликів та рекурсивне програмування (аналогія підземелля)

Пошук скарбу та вихід

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

1. Важко (довго) знайти скарб, оскільки вам доведеться розгадати (потенційно важкі) загадки, щоб потрапити туди.
2. Після того, як скарб знайдений, повернення до входу може бути простим, вам просто потрібно використовувати той самий шлях у іншому напрямку (хоча для запам’ятовування цього шляху потрібно трохи пам’яті).

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

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

Виконання рекурсивної програми

В основному, це саме те саме, що і пошук скарбу. Підземелля - це пам’ять комп’ютера , ваша мета зараз - не знайти скарб, а обчислити якусь функцію (знайти f (x) для даного x ). Індикації просто підпрограми, які допоможуть вам вирішити f (x) . Ваша стратегія така ж, як стратегія стека викликів , ноутбук - це стек, номери - це зворотні адреси функцій:

x = ["over here", "am", "I"]
y = sorted(x) # You're about to enter a room named `sorted`, note down the current room address here so you can return back: 0x4004f4 (that room address looks weird)
# Seems like you went back from your quest using the return address 0x4004f4
# Let's see what you've collected 
print(' '.join(y))

Проблема, з якою ви зіткнулися в підземеллі, буде однаковою тут, стек викликів має обмежений розмір (тут 1000), і тому, якщо ви вводите занадто багато функцій, не повертаючись назад, то ви заповните стек викликів і отримаєте помилку на кшталт "Шановний авантюрист, мені дуже шкода, але ваш ноутбук заповнений" :RecursionError: maximum recursion depth exceeded . Зауважте, що для заповнення стека викликів вам не потрібна рекурсія, але дуже малоймовірно, що нерекурсивна програма викликає 1000 функцій, не повертаючись ніколи. Важливо також розуміти, що після повернення з функції стек виклику звільняється від використовуваної адреси (звідси і назва "стек", повертаюча адреса вводиться перед введенням функції та вилучається при поверненні). В окремому випадку простої рекурсії (функціяfщо дзвонить собі раз і знову -) ви будете входити fзнову і знову, поки обчислення не будуть закінчені (поки скарб не знайдеться) і повернетесь, fпоки не повернетесь туди, куди ви зателефонували fв першу чергу. Стек викликів ніколи не буде звільнений від нічого до кінця, коли він буде звільнений від усіх зворотних адрес одна за одною.

Як уникнути цього питання?

Це насправді досить просто: "не використовуйте рекурсії, якщо ви не знаєте, наскільки глибоко це може пройти". Це не завжди так, як в деяких випадках, рекурсія виклику хвоста може бути оптимізована (TCO) . Але в python це не так, і навіть «добре написана» рекурсивна функція не оптимізує використання стеку. З цього питання є цікавий пост від Гуйдо: Усунення рекурсії хвоста .

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

1. натисніть на поточний список addressі indexв a stackпри введенні нового підсписку (зауважте, що адреса списку + індекс - це також адреса, тому ми просто використовуємо точно таку саму техніку, яку використовує стек викликів);
2. кожного разу, коли предмет знайдеться, yieldвін (або додавати їх у список);
3. як тільки список буде повністю досліджений, поверніться до батьківського списку, використовуючи stack return address(і index) .

Також зауважте, що це еквівалентно DFS у дереві, де деякі вузли є підсписками, A = [1, 2]а деякі - простими елементами: 0, 1, 2, 3, 4(для L = [0, [1,2], 3, 4]). Дерево виглядає так:

                    L
                    |
           -------------------
           |     |     |     |
           0   --A--   3     4
               |   |
               1   2

Попереднє замовлення DFS: L, 0, A, 1, 2, 3, 4. Пам'ятайте, що для реалізації ітеративного DFS вам також потрібен стек. Реалізація, яку я запропонував раніше, призвела до наявності наступних станів (для stackі flat_list)

init.:  stack=[(L, 0)]
**0**:  stack=[(L, 0)],         flat_list=[0]
**A**:  stack=[(L, 1), (A, 0)], flat_list=[0]
**1**:  stack=[(L, 1), (A, 0)], flat_list=[0, 1]
**2**:  stack=[(L, 1), (A, 1)], flat_list=[0, 1, 2]
**3**:  stack=[(L, 2)],         flat_list=[0, 1, 2, 3]
**3**:  stack=[(L, 3)],         flat_list=[0, 1, 2, 3, 4]
return: stack=[],               flat_list=[0, 1, 2, 3, 4]

У цьому прикладі максимальний розмір стека дорівнює 2, оскільки список вхідних даних (а отже, дерево) має глибину 2.

Впровадження

Для реалізації, у python ви можете трохи спростити, використовуючи ітератори замість простих списків. Посилання на (під) ітераторів використовуватимуться для зберігання зворотних адрес підспісків (замість того, щоб мати як адресу списку, так і індекс). Це не велика різниця, але я вважаю, що це читабельніше (а також трохи швидше):

def flatten(iterable):
    return list(items_from(iterable))

def items_from(iterable):
    cursor_stack = [iter(iterable)]
    while cursor_stack:
        sub_iterable = cursor_stack[-1]
        try:
            item = next(sub_iterable)
        except StopIteration:   # post-order
            cursor_stack.pop()
            continue
        if is_list_like(item):  # pre-order
            cursor_stack.append(iter(item))
        elif item is not None:
            yield item          # in-order

def is_list_like(item):
    return isinstance(item, list)

Крім того, зауважте, що в is_list_likeмені isinstance(item, list), яке можна змінити, щоб обробляти більше типів вводу, тут я просто хотів мати найпростішу версію, де (ітерабельна) - це лише список. Але ви також можете це зробити:

def is_list_like(item):
    try:
        iter(item)
        return not isinstance(item, str)  # strings are not lists (hmm...) 
    except TypeError:
        return False

Це розглядає рядки як "прості елементи", тому flatten_iter([["test", "a"], "b])повертається, ["test", "a", "b"]а не ["t", "e", "s", "t", "a", "b"]. Зауважте, що в такому випадку iter(item)викликується двічі на кожен елемент, давайте зробимо вигляд, що читач робить вправу чистішою.

Тестування та зауваження щодо інших реалізацій

Зрештою, пам’ятайте, що ви не можете надрукувати нескінченно вкладений список, Lвикористовуючи, print(L)оскільки внутрішньо він використовуватиме рекурсивні дзвінки до __repr__( RecursionError: maximum recursion depth exceeded while getting the repr of an object). З тієї ж причини рішення щодо flattenзалучення strне вдасться з тим самим повідомленням про помилку.

Якщо вам потрібно протестувати рішення, ви можете використовувати цю функцію для створення простого вкладеного списку:

def build_deep_list(depth):
    """Returns a list of the form $l_{depth} = [depth-1, l_{depth-1}]$
    with $depth > 1$ and $l_0 = [0]$.
    """
    sub_list = [0]
    for d in range(1, depth):
        sub_list = [d, sub_list]
    return sub_list

Що дає: build_deep_list(5)>>> [4, [3, [2, [1, [0]]]]].

Ось compiler.ast.flattenреалізація в 2.7.5:

def flatten(seq):
    l = []
    for elt in seq:
        t = type(elt)
        if t is tuple or t is list:
            for elt2 in flatten(elt):
                l.append(elt2)
        else:
            l.append(elt)
    return l

Є кращі, швидші методи (Якщо ви досягли тут, ви вже бачили їх)

Також зверніть увагу:

Застаріло з версії 2.6: Пакет компілятора видалено в Python 3.

повністю хакі, але я думаю, що це буде працювати (залежно від вашого типу даних)

flat_list = ast.literal_eval("[%s]"%re.sub("[\[\]]","",str(the_list)))

Просто використовуйте funcyбібліотеку: pip install funcy

import funcy


funcy.flatten([[[[1, 1], 1], 2], 3]) # returns generator
funcy.lflatten([[[[1, 1], 1], 2], 3]) # returns list

Ось ще один підхід py2, я не впевнений, чи це найшвидший чи найелегантніший чи найбезпечніший ...

from collections import Iterable
from itertools import imap, repeat, chain


def flat(seqs, ignore=(int, long, float, basestring)):
    return repeat(seqs, 1) if any(imap(isinstance, repeat(seqs), ignore)) or not isinstance(seqs, Iterable) else chain.from_iterable(imap(flat, seqs))

Він може ігнорувати будь-який конкретний (або похідний) тип, який ви хочете, він повертає ітератор, тож ви можете конвертувати його в будь-який конкретний контейнер, такий як список, кортеж, диктант або просто споживати його, щоб зменшити слід пам'яті в кращу сторону чи гірше він може обробляти початкові неітерабельні об'єкти, такі як int ...

Зауважте, велика частина важкого підйому виконується в C, оскільки, наскільки я знаю, як реалізуються itertools, тому, хоча він є рекурсивним, AFAIK його не обмежує глибина рекурсії пітона, оскільки виклики функцій відбуваються в C, хоча це не означає, що ви обмежені пам'яттю, особливо в OS X, де розмір стека має жорсткий ліміт на сьогодні (OS X Mavericks) ...

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

def flat(seqs, ignore={int, long, float, str, unicode}):
    return repeat(seqs, 1) if type(seqs) in ignore or not isinstance(seqs, Iterable) else chain.from_iterable(imap(flat, seqs))

тут ми використовуємо набори для перевірки типу, тому потрібно O (1) vs O (кількість типів), щоб перевірити, чи слід елемент ігнорувати чи ні, хоча, звичайно, будь-яке значення з похідним типом зазначених ігнорованих типів не буде , ось чому його використання str, unicodeтому використовуйте його з обережністю ...

тести:

import random

def test_flat(test_size=2000):
    def increase_depth(value, depth=1):
        for func in xrange(depth):
            value = repeat(value, 1)
        return value

    def random_sub_chaining(nested_values):
        for values in nested_values:
            yield chain((values,), chain.from_iterable(imap(next, repeat(nested_values, random.randint(1, 10)))))

    expected_values = zip(xrange(test_size), imap(str, xrange(test_size)))
    nested_values = random_sub_chaining((increase_depth(value, depth) for depth, value in enumerate(expected_values)))
    assert not any(imap(cmp, chain.from_iterable(expected_values), flat(chain(((),), nested_values, ((),)))))

>>> test_flat()
>>> list(flat([[[1, 2, 3], [4, 5]], 6]))
[1, 2, 3, 4, 5, 6]
>>>  

$ uname -a
Darwin Samys-MacBook-Pro.local 13.3.0 Darwin Kernel Version 13.3.0: Tue Jun  3 21:27:35 PDT 2014; root:xnu-2422.110.17~1/RELEASE_X86_64 x86_64
$ python --version
Python 2.7.5

Без використання жодної бібліотеки:

def flat(l):
    def _flat(l, r):    
        if type(l) is not list:
            r.append(l)
        else:
            for i in l:
                r = r + flat(i)
        return r
    return _flat(l, [])



# example
test = [[1], [[2]], [3], [['a','b','c'] , [['z','x','y']], ['d','f','g']], 4]    
print flat(test) # prints [1, 2, 3, 'a', 'b', 'c', 'z', 'x', 'y', 'd', 'f', 'g', 4]

Використання itertools.chain:

import itertools
from collections import Iterable

def list_flatten(lst):
    flat_lst = []
    for item in itertools.chain(lst):
        if isinstance(item, Iterable):
            item = list_flatten(item)
            flat_lst.extend(item)
        else:
            flat_lst.append(item)
    return flat_lst

Або без прикування:

def flatten(q, final):
    if not q:
        return
    if isinstance(q, list):
        if not isinstance(q[0], list):
            final.append(q[0])
        else:
            flatten(q[0], final)
        flatten(q[1:], final)
    else:
        final.append(q)

Я використовував рекурсивний для вирішення вкладеного списку з будь-якою глибиною

def combine_nlist(nlist,init=0,combiner=lambda x,y: x+y):
    '''
    apply function: combiner to a nested list element by element(treated as flatten list)
    '''
    current_value=init
    for each_item in nlist:
        if isinstance(each_item,list):
            current_value =combine_nlist(each_item,current_value,combiner)
        else:
            current_value = combiner(current_value,each_item)
    return current_value

Тож після того, як я визначу функцію комбінований список, легко скористатися цією функцією зробити вирівнювання. Або ви можете об'єднати його в одну функцію. Мені подобається моє рішення, оскільки його можна застосувати до будь-якого вкладеного списку.

def flatten_nlist(nlist):
    return combine_nlist(nlist,[],lambda x,y:x+[y])

результат

In [379]: flatten_nlist([1,2,3,[4,5],[6],[[[7],8],9],10])
Out[379]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Найпростіший спосіб - це використання бібліотеки морфів за допомогою pip install morph.

Код такий:

import morph

list = [[[1, 2, 3], [4, 5]], 6]
flattened_list = morph.flatten(list)  # returns [1, 2, 3, 4, 5, 6]

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

def flatten_list(seq):
    if not seq:
        return []
    elif isinstance(seq[0],list):
        return (flatten_list(seq[0])+flatten_list(seq[1:]))
    else:
        return [seq[0]]+flatten_list(seq[1:])

print(flatten_list([1,2,[3,[4],5],[6,7]]))

вихід:

[1, 2, 3, 4, 5, 6, 7]

Я не впевнений, чи це обов'язково швидше чи ефективніше, але це те, що я роблю:

def flatten(lst):
    return eval('[' + str(lst).replace('[', '').replace(']', '') + ']')

L = [[[1, 2, 3], [4, 5]], 6]
print(flatten(L))

Тут flattenфункція перетворює список у рядок, виймає всі квадратні дужки, приєднує квадратні дужки на кінці і повертає його назад у список.

Хоча, якби ви знали, що у вашому списку у рядках будуть квадратні дужки, наприклад [[1, 2], "[3, 4] and [5]"], вам доведеться робити щось інше.

Це простий реалізація flatten на python2

flatten=lambda l: reduce(lambda x,y:x+y,map(flatten,l),[]) if isinstance(l,list) else [l]

test=[[1,2,3,[3,4,5],[6,7,[8,9,[10,[11,[12,13,14]]]]]],]
print flatten(test)

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

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

def flatten_obj(n_obj, key=True, my_sep=''):
    my_string = ''
    if type(n_obj) == list:
        for val in n_obj:
            my_sep_setter = my_sep if my_string != '' else ''
            if type(val) == list or type(val) == dict:
                my_string += my_sep_setter + flatten_obj(val, key, my_sep)
            else:
                my_string += my_sep_setter + val
    elif type(n_obj) == dict:
        for k, v in n_obj.items():
            my_sep_setter = my_sep if my_string != '' else ''
            d_val = k if key else v
            if type(v) == list or type(v) == dict:
                my_string += my_sep_setter + flatten_obj(v, key, my_sep)
            else:
                my_string += my_sep_setter + d_val
    elif type(n_obj) == str:
        my_sep_setter = my_sep if my_string != '' else ''
        my_string += my_sep_setter + n_obj
        return my_string
    return my_string

print(flatten_obj(['just', 'a', ['test', 'to', 'try'], 'right', 'now', ['or', 'later', 'today'],
                [{'dictionary_test': 'test'}, {'dictionary_test_two': 'later_today'}, 'my power is 9000']], my_sep=', ')

врожайність:

just, a, test, to, try, right, now, or, later, today, dictionary_test, dictionary_test_two, my power is 9000

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

def f(E):
    if E==[]: 
        return []
    elif type(E) != list: 
        return [E]
    else:
        a = f(E[0])
        b = f(E[1:])
        a.extend(b)
        return a

Я насправді адаптував це до деякого коду схеми практики, який я писав ще задовго.

Насолоджуйтесь!

Я новачок у python і походжу з фонового малюнка. Ось що я придумав (перевірте назви вар для lulz):

def flatten(lst):
    if lst:
        car,*cdr=lst
        if isinstance(car,(list,tuple)):
            if cdr: return flatten(car) + flatten(cdr)
            return flatten(car)
        if cdr: return [car] + flatten(cdr)
        return [car]

Здається, працює. Тест:

flatten((1,2,3,(4,5,6,(7,8,(((1,2)))))))

повертає:

[1, 2, 3, 4, 5, 6, 7, 8, 1, 2]