Python – Sum of tuple elements

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:

1. Define a function named “summation” that takes a tuple “test_tup” as input.
2. Convert the tuple “test_tup” to a list named “test”.
3. Initialize a variable “count” to zero.
4. Using a “for” loop, iterate over the elements of “test” and add each element to “count”.
5. Return the value of “count”.
6. Initialize a tuple “test_tup” with the values (5, 20, 3, 7, 6, 8).
7. Call the “summation” function with “test_tup” as the argument and print the result.

Python3

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))

Output : 

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:

1. The tuple test_tup is initialized with three inner lists containing integer values.
2. The original tuple is printed using the print() function along with a message string.
3. The sum() function is used to calculate the sum of all the elements of the tuple test_tup.
4. The map() function is applied to test_tup with sum function as its argument to sum the elements of each inner list.
5. The result of the map() function is converted to a list using the list() function.
6. 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.
7. The result of step 6 is stored in the variable res.
8. The result is printed using the print() function along with a message string.

Below is the implementation of the above approach:

Python3

# 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))

Output : 

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

# 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))

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. 
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.

Python3

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

Output

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

# 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.

Python3

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 built-in 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))

Output

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 built-in sum() function

Step-by-step 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 on-the-fly 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:

Python3

def summation2(test_tup):
    # Check if the input is empty or contains non-integer 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 built-in sum() function
    total_sum = sum(iterable)

    return total_sum
test_tup = (5, 20, 3, 7, 6, 8)
print(summation2(test_tup))

Output

49

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