Hogyan lehet egy többdimenziós listát optimálisan egyetlen elemlistává alakítani a Pythonban? [másolat]

Itt van egy iteratív verzió (eredetileg Artsiom Rudzenka ihlette), amely a helyben módosítja a listát szelet hozzárendeléssel, ahelyett, hogy minden egyes lépésnél új listát hozna létre. Érdekes módon a listán csak egyszer kell átmenni! A enumerate() használata kissé szokatlan; Arra használom, hogy nyomon követhessek egy indexet egy listába, amely növekszik, ahogy végigfutom rajta, de valójában nem a tényleges listaelemet használom.

def flattened(items, seqtypes=(list, tuple)):

    items = items[:]  # we will return a copy; remove to mutate original
    for i, _ in enumerate(items):
        while isinstance(items[i], seqtypes):
            items[i:i+1] = items[i]
    return items

print flattened([1,2,[3,4,[5,6,7,[8]]],[9],10])

Generátor verzió:

def flattener(items, seqtypes=(list, tuple)):

    items = items[:]
    for i, _ in enumerate(items):
        while isinstance(items[i], seqtypes):
            items[i:i+1] = items[i]
        yield items[i]

print list(flattener([1,2,[3,4,[5,6,7,[8]]],[9],10]))

Itt van egy list alosztály, amelynek flatten() metódusa van. A sort() és reverse() metódusokhoz hasonlóan ez is mutálja a listát, és a None értéket adja vissza.

class listy(list):

    def flatten(self, seqtypes=(list, tuple)):
        for i, _ in enumerate(self):
            while isinstance(self[i], seqtypes):
                self[i:i+1] = self[i]

lst = listy([1,2,[3,4,[5,6,7,[8]]],[9],10])
lst.flatten()
print lst

Szerk.: Ezt elég jelentősen leegyszerűsítettem az eredeti verziómhoz képest. Viszont úgy látom, a kérdés lezárva.

Lásd ezt a választ:

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

Íme egy egyszerű generátor, amely ezt teszi:

def flatten(nested):
    for item in nested:
        if isinstance(item, collections.Iterable) and not isinstance(item, basestring):
            for inner_item in flatten(item):
                yield inner_item
        else:
            yield item

Nem biztos benne, hogy "optimális"-e vagy sem.

Kipróbáltam az alábbi megoldást és működik:

data = [1,2,[3,4,[5,6,7,[8]]],[9],10]

while any(isinstance(x, list) for x in data):
    tmpLst = []
    for x in data:
        if isinstance(x, list):
            tmpLst.extend(x)
        else:
            tmpLst.append(x)
    data = tmpLst

Egy másik megközelítés..

def flatten(old, new):                                                                                                                      
    for i in old:                                                                                                                           
        flatten(i, new) if isinstance(i, list) else new.append(i)                                                                           
    return new                                                                                                                              

if __name__ == '__main__':                                                                                                                  
    l1 = [1, 2, [3, 4, [5, 6, 7, [8]]], [9], 10]                                                                                            
    l2 = list()                                                                                                                             
    l3 = flatten(l1, l2)                                                                                                                     
    print l3

Leegyszerűsítve, így nem kell megadnia és üresen hagynia a listát az összelapított argumentumlistához.

def rec_flatten(old, new=list()):                                                                                                           
    for i in old:                                                                                                                           
        rec_flatten(i, new) if isinstance(i, list) else new.append(i)                                                                       
    return new                                                                                                                              

if __name__ == '__main__':                                                                                                                  
    l1 = [1, 2, [3, 4, [5, 6, 7, [8]]], [9], 10]                                                                                            
    x = rec_flatten(l1)                                                                                                                     
    print x