Proper way to unbox multi-layered values

Question

I have a multi-layered typle/list container. Manual unboxing the final data with inserted list comprehensions gives me a lot of headache.

[[(23,)],[(124,)],[(45,)]]

What is a proper way to unbox final values in simple list like this ?

[23,124,45]

I`ve already tried google, but i see only explanation whan boxi/unboxing is , but i sure that there should be some short way to do this, except inserted list comprehensions

it the data always nested 3 levels or do you want to unbox with an unknown number of nesting levels? — Michael_Scharf, Mar 20 '14 at 13:24
Thanks tobias_k, i`ve missed word "flatten". Will check opic you`ve posted. It answers on my question 100%. — Danylo Gurianov, Mar 20 '14 at 13:28

score 0 · Answer 1 · answered Mar 20 '14 at 13:23

0

In [1]: v = [[(23,)],[(124,)],[(45,)]]

In [2]: [b[0] for b in [a[0] for a in v]]
Out[3]: [23, 124, 45]

answered Mar 20 '14 at 13:23

Thanks, i thought there is another way to do this. – Danylo Gurianov Mar 20 '14 at 13:27
Another way? Like what? – Mar 20 '14 at 13:29

waylight · Answer 2 · 2014-03-20T14:23:14.643

srcList = [[(23,)],[(124,)],[(45,)]]
dstList = []
#--------------------------------------------------------------------
def Expand( srcList ) :
    if hasattr(srcList, '__iter__'):
        for i in srcList:
            Expand( i )
    else:
        dstList.append( srcList )
#--------------------------------------------------------------------
if __name__ == '__main__':
    Expand( srcList )
    print dstList

another similar approach likes the following code.

#--------------------------------------------------------------------
class   Expander:
    def __init__( self ):
        self.resultList = []

    def Expand( self, srcList ):
        self.resultList = []
        self.Internal_Expand( srcList )
        return self.resultList

    def Internal_Expand( self, srcList ):
        if hasattr(srcList, '__iter__'):
            for i in srcList:
                self.Internal_Expand( i )
        else:
            self.resultList.append( srcList )
#--------------------------------------------------------------------
if __name__ == '__main__':
    srcList = [[(23,)],[(124,)],[(45,)]]
    print Expander().Expand( srcList )
#--------------------------------------------------------------------

ok, finally i find this way.

#--------------------------------------------------------------------
def Expand( srcList ):
    resultList = []
    def Internal_Expand( xList ):
        if hasattr(xList, '__iter__'):
            for i in xList:
                Internal_Expand( i )
        else:
            resultList.append( xList )
    Internal_Expand( srcList )
    return resultList
#--------------------------------------------------------------------
if __name__ == '__main__':
    srcList = [[(23,)],[(124,)],[(45,)]]
    print Expand( srcList )
#--------------------------------------------------------------------

score 0 · Answer 3 · answered Mar 20 '14 at 13:44

Assuming all your data are not iterables, we can use a recursive approach:

import collections

def iterable(obj):
    return isinstance(obj, collections.Iterable)

def unbox(obj):
    if iterable(obj):
        result = []
        for x in obj:
            result.extend(unbox(x))
        return result
    else:
        return [obj]

This approach can be converted into a sequential function if needed:

from collections import deque

def unbox(obj):
    obj_list = deque([obj])
    result = []
    while(len(obj_list) > 0):
        current = obj_list.popleft()
        if iterable(current):
            obj_list.extend(current)
        else:
            result.append(current)
    return result

Proper way to unbox multi-layered values

3 Answers3