In Python flach drücken

Ruby hat eine Methode namens "Abflachen", die ein verschachteltes Array zu einem eindimensionalen Array zusammenfasst. Manchmal möchte ich sie jedoch in Python verwenden. Deshalb habe ich versucht herauszufinden, welche Art von Methode es gibt.

Was du machen willst

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

Die in Qiita gefundene Methode

http://qiita.com/kento1218@github/items/f3baf574aadb3d1cbeae

Machen Sie es zu einer Generatorfunktion

Ich habe versucht, es zu einer Generatorfunktion zu machen, indem ich mich auf die in Qiita gefundene Methode bezog. Zum Auflisten muss es so etwas wie "Liste (Abflachen ([[1, 2], [3, [4, 5]]])") sein.

def flatten(data):
    for item in data:
        if hasattr(item, '__iter__'):
            for element in flatten(item):
                yield element
        else:
            yield item

Machen Sie es zu einer Generatoreinschlussnotation

def flatten(data):
    return (element
            for item in data
            for element in (flatten(item) if hasattr(item, '__iter__') else [item]))

Listeneinschlussnotation

def flatten(data):
    return [element
            for item in data
            for element in (flatten(item) if hasattr(item, '__iter__') else [item])]

Verwenden Sie Funktionen in vorhandenen Bibliotheken

Ich habe es hier gefunden. http://stackoverflow.com/questions/2158395/flatten-an-irregular-list-of-lists-in-python

from compiler.ast import flatten

Reduzieren Sie die Liste der Listen mit der Summenfunktion um Tiefe 1

>>> data = [[1, 2], [3], [4, 5, [6]]]
>>> sum(data, [])
[1, 2, 3, 4, 5, [6]]

Funktion mit Tiefenangabe

In Ruby können Sie die Tiefe angeben, die abgeflacht werden soll, daher habe ich versucht, sie zu unterstützen.

flatten.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-

def flatten(data, depth=-1):
    """
    flatten(data) -> list
    flatten(data, depth) -> list

    Return flatted data of list or tupple as list.

    >>> data = [[1, 2], [3, [4, 5, [6]]]]
    >>> flatten(data)
    [1, 2, 3, 4, 5, 6]
    >>> flatten(data, 0)
    [[1, 2], [3, [4, 5, [6]]]]
    >>> flatten(data, 1)
    [1, 2, 3, [4, 5, [6]]]
    >>> flatten(data, 2)
    [1, 2, 3, 4, 5, [6]]
    >>> flatten(data, 3)
    [1, 2, 3, 4, 5, 6]
    """
    return [element
            for item in data
            for element in (flatten(item, depth - 1)
                            if depth != 0 and hasattr(item, '__iter__')
                            else [item])
            ]

$ python -m doctest -v flatten.py
Trying:
    data = [[1, 2], [3, [4, 5, [6]]]]
Expecting nothing
ok
Trying:
    flatten(data)
Expecting:
    [1, 2, 3, 4, 5, 6]
ok
Trying:
    flatten(data,0)
Expecting:
    [[1, 2], [3, [4, 5, [6]]]]
ok
Trying:
    flatten(data, 1)
Expecting:
    [1, 2, 3, [4, 5, [6]]]
ok
Trying:
    flatten(data, 2)
Expecting:
    [1, 2, 3, 4, 5, [6]]
ok
Trying:
    flatten(data, 3)
Expecting:
    [1, 2, 3, 4, 5, 6]
ok
1 items had no tests:
    flatten
1 items passed all tests:
   6 tests in flatten.flatten
6 tests in 2 items.
6 passed and 0 failed.
Test passed.