Get the best out of our app
GeeksforGeeks App
Open App
Browser
Continue

# Python – How to Multiply all items in Tuple

Sometimes, while programming, we have a problem in which we might need to perform product among tuple elements. This is an essential utility as we come across product operation 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() + loop The above functions can be combined to perform this task. We can employ loop to accumulate the result of product logic. The list() function is used to perform interconversions.

## Python3

 `# Python3 code to demonstrate working of``# Tuple Elements Multiplication``# Using list() + loop` `# getting Product``def` `prod(val) :``    ``res ``=` `1``    ``for` `ele ``in` `val:``        ``res ``*``=` `ele``    ``return` `res ` `# initializing tup``test_tup ``=` `(``7``, ``8``, ``9``, ``1``, ``10``, ``7``)` `# printing original tuple``print``("The original ``tuple` `is` `: " ``+` `str``(test_tup))` `# Tuple Elements Multiplication``# Using list() + loop``res ``=` `prod(``list``(test_tup))` `# printing result``print``("The product of ``tuple` `elements are : " ``+` `str``(res))`

Output :

```The original tuple is : (7, 8, 9, 1, 10, 7)
The product of tuple elements are : 35280```

Time complexity: O(n), where n is the length of the tuple.
Auxiliary space: O(n), to store the list created from the tuple.

Method #2 : Using map() + loop + 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 product of each using loop and again employ loop for overall product of resultant list.

## Python3

 `# Python 3 code to demonstrate working of``# Tuple Elements Multiplication``# Using map() + list() + loop` `# getting Product``def` `prod(val) :``    ``res ``=` `1``    ``for` `ele ``in` `val:``        ``res ``*``=` `ele``    ``return` `res ` `# initializing tup``test_tup ``=` `([``7``, ``8``], [``9``, ``1``], [``10``, ``7``])` `# printing original tuple``print``("The original ``tuple` `is` `: " ``+` `str``(test_tup))` `# Tuple Elements Multiplication``# Using map() + list() + loop``res ``=` `prod(``list``(``map``(prod, ``list``(test_tup))))` `# printing result``print``("The product of ``tuple` `elements are : " ``+` `str``(res))`

Output :

```The original tuple is : (7, 8, 9, 1, 10, 7)
The product of tuple elements are : 35280```

Time Complexity: O(n), where n is the number of elements in the list “test_list”.
Auxiliary Space: O(1), constant extra space is required

Method #3 : Here is an approach using the reduce function from the functools library, along with an anonymous lambda function:

## Python3

 `# Python 3 code to demonstrate working of``# Tuple Elements Multiplication``# Using reduce() and lambda function``  ` `from` `functools ``import` `reduce``  ` `# getting Product``def` `prod(val) :``    ``return` `reduce``((``lambda` `x, y: x ``*` `y), val)``  ` `# initializing tup``test_tup ``=` `(``7``, ``8``, ``9``, ``1``, ``10``, ``7``)``  ` `# printing original tuple``print``(``"The original tuple is : "` `+` `str``(test_tup))``  ` `# Tuple Elements Multiplication``# Using reduce() and lambda function``res ``=` `prod(test_tup)``  ` `# printing result``print``(``"The product of tuple elements are : "` `+` `str``(res))`

Output

```The original tuple is : (7, 8, 9, 1, 10, 7)
The product of tuple elements are : 35280```

Time Complexity: O(n), where n is the length of the tuple, as it needs to iterate through the tuple once to calculate the product.
Auxiliary Space: O(1), as it only uses a single variable res to store the result.

Method #4 : Using functools.reduce() and operator.mul

## Python3

 `# Python3 code to demonstrate working of``# Tuple Elements Multiplication` `# initializing tup``test_tup ``=` `(``7``, ``8``, ``9``, ``1``, ``10``, ``7``)` `# printing original tuple``print``(``"The original tuple is : "` `+` `str``(test_tup))` `# Tuple Elements Multiplication``from` `functools ``import` `reduce``import` `operator``res``=``reduce``(operator.mul, test_tup , ``1``)` `# printing result``print``(``"The product of tuple elements are : "` `+` `str``(res))`

Output

```The original tuple is : (7, 8, 9, 1, 10, 7)
The product of tuple elements are : 35280```

Time Complexity : O(N)
Auxiliary Space : O(1)

Method 5: Using numpy module

Note: use “pip install numpy” to install

we use the np.prod() function of the numpy module to find the product of all the elements in the input tuple. The np.prod() function takes an array or a sequence of numbers as input and returns the product of all the elements in it.

• Import the numpy module using the import statement.
• Initialize a tuple test_tup with the given set of values .
• Print the original tuple using the print() function and concatenation operator.
• Use the np.prod() function of the numpy module to find the product of all the elements in the input tuple.
• Assign the result to a variable res.
• Print the result using the print() function and concatenation operator.

Below is the implementation of the above approach:

## Python3

 `# Python3 code to demonstrate working of``# Tuple Elements Multiplication``# Using numpy module` `import` `numpy as np` `# initializing tup``test_tup ``=` `(``7``, ``8``, ``9``, ``1``, ``10``, ``7``)` `# printing original tuple``print``(``"The original tuple is : "` `+` `str``(test_tup))` `# Tuple Elements Multiplication``# Using numpy module``res ``=` `np.prod(test_tup)` `# printing result``print``(``"The product of tuple elements are : "` `+` `str``(res))`

Output:

```The original tuple is : (7, 8, 9, 1, 10, 7)
The product of tuple elements are : 35280```

Time complexity: O(n), The np.prod() function has a time complexity of O(n) as it iterates over all the elements of the input tuple once to calculate the product.
Auxiliary Space: O(1),  as the np.prod() function does not use any additional space to store the input and output values. The variable res created to store the output takes constant space.

Method: Using while() method-

• result variable is initialized to 1 which will store the answer
• i is initialized to 0 for while loop.
• A while loop is used to iterate over the elements of test_tup using an index i.
• In each iteration, the value at the ith index of test_tup is multiplied with the current value of result using *=, and the result is stored back in the result.
• Then index is increased to go to the next iteration.
• after while loop breaks the result is printed.

## Python3

 `test_tup ``=` `(``7``, ``8``, ``9``, ``1``, ``10``, ``7``)``result ``=` `1``i ``=` `0` `while` `i < ``len``(test_tup):``    ``result ``*``=` `test_tup[i]``    ``i ``+``=` `1` `print``(result)`

Output

`35280`

Time Complexity: O(n) as we are traversing to each element in a tuple so time complexity is O(N)

Space Complexity: O(1) because we are not using any extra space. So space complexity is O(1).

My Personal Notes arrow_drop_up