Python convert different depth list of tuples to flatten list of tuples

Question

I have a tuple of characters like such:

p= [((4.0, 4.0), '->', ((4, 2), (4, 8)), ((2, 2), (5, 5))), ((4.0, 7.0), '->', ((4, 2), (4, 8)), ((5, 6), (3, 8)))]`

How do I convert it to a tupple so that it is like:

p = [(4.0,4.0), (4, 2), (4, 8), (2, 2), (5, 5),(4.0, 7.0), (4, 2), (4, 8), (5, 6), (3, 8) ]

`

I was trying this way but output is coming with double bracket for some

res = []
for tup in p:
    for sub_tup in tup:
        print sub_tup, type(sub_tup)
        if type(sub_tup) == tuple:
            res.append(sub_tup)
            
print(res)

Output

  [(4.0, 4.0), ((4, 2), (4, 8)), ((2, 2), (5, 5)), (4.0, 7.0), ((4, 2), (4, 8)), ((5, 6), (3, 8))]

elements are coming in form (4.0, 4.0) -> ((4, 2), (4, 8)) how do i remove these -> and )) @mkrieger1 — amit, Jan 26 '23 at 20:12
What is the rule for getting from your first list to your second list? — Max, Jan 26 '23 at 20:13
i was using 2 loops to find elements and then subsequently pushing them @Max — amit, Jan 26 '23 at 20:15
Do you mean that you want to remove all elements that are strings? — mkrieger1, Jan 26 '23 at 20:21

score 1 · Accepted Answer · answered Jan 26 '23 at 20:52

You can write a recursive solution like the below:

p = [((4.0, 4.0), '->', ((4, 2), (4, 8)), ((2, 2), (5, 5))), ((4.0, 7.0), '->', ((4, 2), (4, 8)), ((5, 6), (3, 8)))]

def rec_flat(tpl, result):
    for t in tpl:
        if type(t[0]) not in [str, tuple]:
            result.append(t)
        elif isinstance(t, tuple):
            rec_flat(t, result)



result = []
rec_flat(p, result)
print(result)

Output:

[(4.0, 4.0), (4, 2), (4, 8), (2, 2), (5, 5), (4.0, 7.0), (4, 2), (4, 8), (5, 6), (3, 8)]

score 0 · Answer 2 · answered Jan 26 '23 at 20:21

This solution uses an external library more_itertools.

Here's a rundown:

Collapse the p structure all the way down to non-iterable elements. The result is a 1-D array/list.
Remove '->' from the list.
Take every two elements from the list and put them together.

from pprint import pprint
from more_itertools import collapse, sliced

p = [((4.0, 4.0), '->', ((4, 2), (4, 8)), ((2, 2), (5, 5))), ((4.0, 7.0), '->', ((4, 2), (4, 8)), ((5, 6), (3, 8)))]

p2 = collapse(p)
p3 = filter(lambda x: isinstance(x, (int, float)), p2)
p4 = sliced(list(p3), 2)

pprint(list(p4))

Result:

[[4.0, 4.0],
 [4, 2],
 [4, 8],
 [2, 2],
 [5, 5],
 [4.0, 7.0],
 [4, 2],
 [4, 8],
 [5, 6],
 [3, 8]]

can we do it without importing external packages @Fractalism — amit, Jan 26 '23 at 20:24

Michael Cao · Answer 3 · 2023-01-26T20:53:26.220

0

Use list comprehension to flatten list and then isinstance to filter out strings.

p= [((4.0, 4.0), '->', ((4, 2), (4, 8)), ((2, 2), (5, 5))), ((4.0, 7.0), '->', ((4, 2), (4, 8)), ((5, 6), (3, 8)))]

output = [m if not isinstance(m, (int, float)) else n for o in p for n in o for m in n if not isinstance(n, str)]
output = [item for i, item in enumerate(output) if output[i] != output[i-1]]

First output almost produces the right output but with a duplicate of the item preceding the '->', so we just remove the duplicates in the next line.

edited Jan 26 '23 at 20:53

answered Jan 26 '23 at 20:23

Michael Cao

2,278
1
1
13

output [(4.0, 4.0), ((4, 2), (4, 8)), ((2, 2), (5, 5)), (4.0, 7.0), ((4, 2), (4, 8)), ((5, 6), (3, 8))] is different then what I expect p = [(4.0,4.0), (4, 2), (4, 8), (2, 2), (5, 5),(4.0, 7.0), (4, 2), (4, 8), (5, 6), (3, 8) ] it has doubled (( in 2,2.. @Michael Cao – amit Jan 26 '23 at 20:27
Indeed, there's one more imbedding depth that you didn't take into account. – Swifty Jan 26 '23 at 20:28
@amit Whoops, that's on me for not reading the problem close enough. I produced a somewhat hacky workaround to get the desired output. – Michael Cao Jan 26 '23 at 20:54

score 0 · Answer 4 · answered Jan 26 '23 at 20:44

You can flatten the list recursively manually. This is not the most elegant way to do that, but it returns the right result:

L = []
def flatten(p):
    tupFlag = 0
    for el in p:
        if type(el) == tuple:
            tupFlag = 1
            e = flatten(el)
            if e != None:
                 L.append(flatten(e))
    if tupFlag==0:
        return p

flatten(p)
print(L)

score 0 · Answer 5 · answered Jan 26 '23 at 20:46

Here's a recursive solution, traversing iterables until a 2-tuple of numbers is found, and ignoring anything non-iterable.

from pprint import pprint

p = [((4.0, 4.0), '->', ((4, 2), (4, 8)), ((2, 2), (5, 5))), ((4.0, 7.0), '->', ((4, 2), (4, 8)), ((5, 6), (3, 8)))]

def get_pairs(item):
    pairs = []
    if isinstance(item, (list, tuple)):
        # if item is a pair of numbers
        if (len(item) == 2 and 
            isinstance(item[0], (int, float)) and 
            isinstance(item[1], (int, float))):
            return [item]
        else:
            # item is a non-basic iterable
            for subitem in item:
                pairs.extend(get_pairs(subitem))
    else:
        # item is not list or tuple, ignore it
        pass
    return pairs

x = get_pairs(p)

pprint(x)

Result:

[(4.0, 4.0),
 (4, 2),
 (4, 8),
 (2, 2),
 (5, 5),
 (4.0, 7.0),
 (4, 2),
 (4, 8),
 (5, 6),
 (3, 8)]

Python convert different depth list of tuples to flatten list of tuples

5 Answers5