Unpacking Nested Tuples-Python

The task of unpacking nested tuples in Python involves iterating through a list of tuples, extracting values from both the outer and inner tuples and restructuring them into a flattened format. For example, a = [(4, (5, 'Gfg')), (7, (8, 6))] becomes [(4, 5, 'Gfg'), (7, 8, 6)].

Using list comprehension

List comprehension is the most efficient way to unpack nested tuples. It processes elements in a single, optimized iteration, making it faster than traditional loops. This approach improves code readability and execution speed by directly unpacking values while iterating over the list.

a = [(4, (5, 'Gfg')), (7, (8, 6))]
res = [(x, y, z) for x, (y, z) in a]
print(res)

[(4, 5, 'Gfg'), (7, 8, 6)]

Explanation: list comprehension iterate over a, extracting x from the outer tuple and y, z from the inner tuple. It then restructures them into a flat tuple (x, y, z), effectively unpacking the nested tuples in a single step.

Using map()

map() provides a functional programming approach to unpacking nested tuples. It applies a lambda function to each tuple in the list, extracting and restructuring the values. While effective, it is slightly slower than list comprehension due to function call overhead.

a = [(4, (5, 'Gfg')), (7, (8, 6))]
res = list(map(lambda t: (t[0], t[1][0], t[1][1]), a))
print(res)

[(4, 5, 'Gfg'), (7, 8, 6)]

Explanation: map() with a lambda function unpack each tuple in a, extracting the outer element and the inner tuple elements and then creates a new tuple with the values (t[0], t[1][0], t[1][1]).

Using itertoools.chain()

itertools.chain() helps flatten the nested structure by combining the first element with the unpacked inner tuple. Though it works, this method is not the most efficient for simple tuple unpacking, as it introduces additional function call overhead.

from itertools import chain
a = [(4, (5, 'Gfg')), (7, (8, 6))]
res = [tuple(chain((x,), y_z)) for x, y_z in a]
print(res)

[(4, 5, 'Gfg'), (7, 8, 6)]

Explanation: itertools.chain() flatten each tuple in a. It combines the outer element x with the elements of the inner tuple y_z, creating a new tuple. The result is a list of unpacked tuples.

Using for loop

A standard for loop is a straightforward way to unpack nested tuples. It iterates through each tuple, extracts the values, and appends them to a new list. While easy to understand, this method is slightly slower due to explicit .append() operations in each iteration.

a = [(4, (5, 'Gfg')), (7, (8, 6))]
res = [] # initialize empty list
for x, (y, z) in a:
    res.append((x, y, z))
print(res)

[(4, 5, 'Gfg'), (7, 8, 6)]

Explanation: for loop iterates over a, unpacking each tuple into x, y and z then appends the flattened tuple (x, y, z) to the res list.