# Addition in Nested Tuples – Python

Last Updated : 06 Apr, 2023

Sometimes, while working with records, we can have a problem in which we require to perform index wise addition of tuple elements. This can get complicated with tuple elements to be tuple and inner elements again be tuple. Let’s discuss certain ways in which this problem can be solved.

Method #1: Using zip() + nested generator expression The combination of above functions can be used to perform the task. In this, we combine the elements across tuples using zip(). The iterations and summation logic is provided by generator expression.

## Python3

 `# Python3 code to demonstrate working of ` `# Addition in nested tuples ` `# using zip() + nested generator expression `   `# initialize tuples ` `test_tup1 ``=` `((``1``, ``3``), (``4``, ``5``), (``2``, ``9``), (``1``, ``10``)) ` `test_tup2 ``=` `((``6``, ``7``), (``3``, ``9``), (``1``, ``1``), (``7``, ``3``)) `   `# printing original tuples ` `print``(``"The original tuple 1 : "` `+` `str``(test_tup1)) ` `print``(``"The original tuple 2 : "` `+` `str``(test_tup2)) `   `# Addition in nested tuples ` `# using zip() + nested generator expression ` `res ``=` `tuple``(``tuple``(a ``+` `b ``for` `a, b ``in` `zip``(tup1, tup2)) ` `            ``for` `tup1, tup2 ``in` `zip``(test_tup1, test_tup2)) `   `# printing result ` `print``(``"The resultant tuple after summation : "` `+` `str``(res)) `

Output

```The original tuple 1 : ((1, 3), (4, 5), (2, 9), (1, 10))
The original tuple 2 : ((6, 7), (3, 9), (1, 1), (7, 3))
The resultant tuple after summation : ((7, 10), (7, 14), (3, 10), (8, 13))```

Time complexity: O(n^2) where n is the length of the input tuples, because the program uses nested loops to iterate through the tuples.
Auxiliary Space: O(n^2), because the program creates a new tuple of the same size as the input tuples to store the result.

Method #2: Using isinstance() + zip() + loop + list comprehension The combination of above functions can be used to perform this particular task. In this, we check for the nesting type and perform recursion. This method can give flexibility of more than 1 level nesting.

## Python3

 `# Python3 code to demonstrate working of ` `# Addition in nested tuples ` `# using isinstance() + zip() + loop + list comprehension `   `# function to perform task ` `def` `tup_sum(tup1, tup2): ` `    ``if` `isinstance``(tup1, (``list``, ``tuple``)) ``and` `isinstance``(tup2, (``list``, ``tuple``)): ` `       ``return` `tuple``(tup_sum(x, y) ``for` `x, y ``in` `zip``(tup1, tup2)) ` `    ``return` `tup1 ``+` `tup2 `   `# initialize tuples ` `test_tup1 ``=` `((``1``, ``3``), (``4``, ``5``), (``2``, ``9``), (``1``, ``10``)) ` `test_tup2 ``=` `((``6``, ``7``), (``3``, ``9``), (``1``, ``1``), (``7``, ``3``)) `   `# printing original tuples ` `print``(``"The original tuple 1 : "` `+` `str``(test_tup1)) ` `print``(``"The original tuple 2 : "` `+` `str``(test_tup2)) `   `# Addition in nested tuples ` `# using isinstance() + zip() + loop + list comprehension ` `res ``=` `tuple``(tup_sum(x, y) ``for` `x, y ``in` `zip``(test_tup1, test_tup2)) `   `# printing result ` `print``(``"The resultant tuple after summation : "` `+` `str``(res)) `

Output

```The original tuple 1 : ((1, 3), (4, 5), (2, 9), (1, 10))
The original tuple 2 : ((6, 7), (3, 9), (1, 1), (7, 3))
The resultant tuple after summation : ((7, 10), (7, 14), (3, 10), (8, 13))```

Time complexity: O(n), where n is the total number of elements in the input tuples.
Auxiliary space: O(n), where n is the total number of elements in the input tuples.

Method 3: Using numpy
Note: Install numpy module using command “pip install numpy”

This approach uses numpy to perform element-wise addition on the nested tuples. It requires numpy to be installed, then it can be done as follows:

## Python3

 `import` `numpy as np`   `# Initializing the two tuples for element-wise addition` `test_tup1 ``=` `((``1``, ``3``), (``4``, ``5``), (``2``, ``9``), (``1``, ``10``))` `test_tup2 ``=` `((``6``, ``7``), (``3``, ``9``), (``1``, ``1``), (``7``, ``3``))` `# printing original tuples` `print``(``"The original tuple 1 : "` `+` `str``(test_tup1))` `print``(``"The original tuple 2 : "` `+` `str``(test_tup2))` `# Using numpy to perform element-wise addition on the nested tuples` `res ``=` `tuple``(``tuple``(i) ``for` `i ``in` `np.add(test_tup1, test_tup2))`   `#Printing the final result` `print``(res)` `#This code is contributed by Edula Vinay Kumar Reddy`

Output:

```The original tuple 1 : ((1, 3), (4, 5), (2, 9), (1, 10))
The original tuple 2 : ((6, 7), (3, 9), (1, 1), (7, 3))
((7, 10), (7, 14), (3, 10), (8, 13))
```

Time complexity: O(n) where n is the number of elements in the nested tuple.
Auxiliary Space: O(n)

Method 4: Using map() and lambda function

Use the map() function and a lambda function to perform element-wise addition on the nested tuples.

Step-by-step approach:

• Define a lambda function that takes two tuples as arguments and returns a tuple with element-wise addition of the two tuples.
• Use the map() function to apply the lambda function to each pair of tuples from the two original tuples.
• Convert the result to a tuple of tuples using the tuple() function.

Below is the implementation of the above approach:

## Python3

 `# Initializing the two tuples for element-wise addition` `test_tup1 ``=` `((``1``, ``3``), (``4``, ``5``), (``2``, ``9``), (``1``, ``10``))` `test_tup2 ``=` `((``6``, ``7``), (``3``, ``9``), (``1``, ``1``), (``7``, ``3``))`   `# Define a lambda function for element-wise addition` `add_tuple ``=` `lambda` `x, y: ``tuple``(``map``(``sum``, ``zip``(x, y)))`   `# Apply the lambda function to each pair of tuples using map()` `result ``=` `tuple``(``map``(add_tuple, test_tup1, test_tup2))`   `# Print the final result` `print``(result)`

Output

`((7, 10), (7, 14), (3, 10), (8, 13))`

Time complexity: O(n), where n is the number of tuples in the original tuples.
Auxiliary space: O(n), since we need to create a new tuple to store the result.

Method 6: Using a for loop and append()

1. Two tuples, test_tup1 and test_tup2, are initialized with element-wise addition values.
2. An empty list result is initialized to store the results of the element-wise addition.
3. A for loop is set up to iterate over the length of test_tup1 using the range() function.
4. For each iteration of the loop, sum_tuple is initialized with an expression that adds the corresponding elements of test_tup1 and test_tup2 for the current iteration.
5. The sum_tuple is appended to the result list using the append() method.
6. After the for loop completes, result is converted to a tuple using the tuple() function.
7. Finally, the resulting tuple is printed using the print() function.

## Python3

 `# Initializing the two tuples for element-wise addition` `test_tup1 ``=` `((``1``, ``3``), (``4``, ``5``), (``2``, ``9``), (``1``, ``10``))` `test_tup2 ``=` `((``6``, ``7``), (``3``, ``9``), (``1``, ``1``), (``7``, ``3``))`   `# Initialize an empty list to store the results` `result ``=` `[]`   `# Loop over the tuples and add the elements` `for` `i ``in` `range``(``len``(test_tup1)):` `    ``sum_tuple ``=` `tuple``([test_tup1[i][j] ``+` `test_tup2[i][j] ``for` `j ``in` `range``(``len``(test_tup1[i]))])` `    ``result.append(sum_tuple)`   `# Convert the list to a tuple and print the final result` `result ``=` `tuple``(result)` `print``(result)`

Output

`((7, 10), (7, 14), (3, 10), (8, 13))`

Time Complexity: O(n^2) where n is the length of the tuples. The for loop has to iterate over each element in both tuples, so the time complexity is quadratic.

Auxiliary Space: O(n) where n is the length of the tuples. The append() method is used to add each element

Previous
Next