Sometimes, while programming, we have a problem in which we might need to perform summation among tuple elements. This is an essential utility as we come across summation operations many times and tuples are immutable and hence required to be dealt with. Let’s discuss certain ways in which this task can be performed.
Method #1: Using list() + sum() The above functions can be combined to perform this task. We can employ sum() to accumulate the result of summation logic. The list() function is used to perform interconversions.
step by step approach for the program:
 Define a function named “summation” that takes a tuple “test_tup” as input.
 Convert the tuple “test_tup” to a list named “test”.
 Initialize a variable “count” to zero.
 Using a “for” loop, iterate over the elements of “test” and add each element to “count”.
 Return the value of “count”.
 Initialize a tuple “test_tup” with the values (5, 20, 3, 7, 6, 8).
 Call the “summation” function with “test_tup” as the argument and print the result.
def summation(test_tup):
# converting into list
test = list (test_tup)
# initializing count
count = 0
# for loop
for i in test:
count + = i
return count
# initializing test_tup test_tup = ( 5 , 20 , 3 , 7 , 6 , 8 )
print (summation(test_tup))

The original tuple is : (7, 8, 9, 1, 10, 7) The summation of tuple elements are : 42
Time complexity: O(n)
Auxiliary space: O(n) – due to the creation of a new list from the tuple.
Method #2: Using map() + sum() + list() The combination of above functions can be used to perform this task. In this, we first convert the tuple to list, flatten it’s each list element using map(), perform summation of each using sum() and again employ sum() for overall summation of the resultant list.
Follow the below steps to implement the above idea:
 The tuple test_tup is initialized with three inner lists containing integer values.
 The original tuple is printed using the print() function along with a message string.
 The sum() function is used to calculate the sum of all the elements of the tuple test_tup.
 The map() function is applied to test_tup with sum function as its argument to sum the elements of each inner list.
 The result of the map() function is converted to a list using the list() function.
 The result of step 5 is then passed as an argument to the sum() function to add up all the sums of inner lists and get the total sum of all elements in the tuple.
 The result of step 6 is stored in the variable res.
 The result is printed using the print() function along with a message string.
Below is the implementation of the above approach:
# Python 3 code to demonstrate working of # Tuple elements inversions # Using map() + list() + sum() # initializing tup test_tup = ([ 7 , 8 ], [ 9 , 1 ], [ 10 , 7 ])
# printing original tuple print ( "The original tuple is : " + str (test_tup))
# Tuple elements inversions # Using map() + list() + sum() res = sum ( list ( map ( sum , list (test_tup))))
# printing result print ( "The summation of tuple elements are : " + str (res))

The original tuple is : (7, 8, 9, 1, 10, 7) The summation of tuple elements are : 42
Time complexity: O(n^2) where n is the size of the tuple.
Auxiliary space: O(n) where n is the size of the tuple.
Method #3: Using for loop
# Python3 code to demonstrate working of # Tuple summation # initializing tup test_tup = ( 7 , 8 , 9 , 1 , 10 , 7 )
# printing original tuple print ( "The original tuple is : " + str (test_tup))
res = 0
for i in test_tup:
res + = i
# printing result print ( "The summation of tuple elements are : " + str (res))

The original tuple is : (7, 8, 9, 1, 10, 7) The summation of tuple elements are : 42
Time complexity: O(n) where n is the number of elements in the tuple.
Auxiliary space: O(1) because it uses a constant amount of extra space to store the variable “res” which is used to accumulate the summation of the elements in the tuple.
Method #4: Using reduce() + operator.add()
The reduce() function can be used to iterate through the tuple and the operator.add() function can be used for summation of elements.
import operator
from functools import reduce
def summation(test_tup):
# Using reduce() + operator.add() return reduce (operator.add, test_tup)
#initializing test_tup test_tup = ( 5 , 20 , 3 , 7 , 6 , 8 )
print (summation(test_tup))
#This code is contributed by Edula Vinay Kumar Reddy 
49
Time Complexity: O(n) where n is the number of elements in the tuple.
Auxiliary Space: O(1) as no extra space is required.
Method 5: Using the numpy library
Note: Install numpy module using command “pip install numpy”
To find the sum of the elements in a tuple, we could convert the tuple to a numpy array and then use the numpy.sum() function.
# Python3 code to demonstrate working of # Tuple summation using numpy import numpy as np
# initializing tup test_tup = ( 7 , 8 , 9 , 1 , 10 , 7 )
# converting tuple to numpy array test_array = np.array(test_tup)
# printing original tuple print ( "The original tuple is : " + str (test_tup))
# finding sum of array elements res = np. sum (test_array)
# printing result print ( "The summation of tuple elements are : " + str (res))

Output:
The original tuple is : (7, 8, 9, 1, 10, 7) The summation of tuple elements are : 42
Time complexity: O(n), where n is the number of elements in the tuple. This is because the numpy.sum() function also needs to iterate over all n elements in the array to find the sum.
Auxiliary space: O(n), as it requires the creation of a numpy array to store all n elements of the tuple.\
Method 6: Using a list comprehension:
Use a list comprehension to convert the tuple to a list and sum up the elements.
def summation(test_tup):
# Convert the tuple to a list using a list comprehension
test = [x for x in test_tup]
# Find the sum of the elements in the list using the builtin sum() function
return sum (test)
# Test the function with a tuple of integers test_tup = ( 5 , 20 , 3 , 7 , 6 , 8 )
print (summation(test_tup))

49
Time complexity: O(n), where n is the number of elements in the tuple.
Auxiliary space: O(n)
Method 7: Using a generator expression and the builtin sum() function
Stepbystep approach:
 Define a function summation2() that takes a tuple test_tup as its argument.
 Use a generator expression to convert test_tup to an iterable that can be passed to the sum() function. A generator expression is similar to a list comprehension but does not create a list in memory, instead, it generates values onthefly as they are needed.
 Pass the generator expression to the sum() function to find the sum of the elements in test_tup.
 Return the sum.
Below is the implementation of the above approach:
def summation2(test_tup):
# Check if the input is empty or contains noninteger elements
if len (test_tup) = = 0 :
raise ValueError( "Input tuple is empty" )
if not all ( isinstance (x, int ) for x in test_tup):
raise TypeError( "Input tuple must contain only integers" )
# Use a generator expression to convert the tuple to an iterable
iterable = (x for x in test_tup)
# Find the sum of the elements in the iterable using the builtin sum() function
total_sum = sum (iterable)
return total_sum
test_tup = ( 5 , 20 , 3 , 7 , 6 , 8 )
print (summation2(test_tup))

49
Time complexity: O(n)
Auxiliary space: O(1) – only a single variable total_sum is used.