Multiply tuple by scalar python

Simplish thing if you're writing a bunch of code, but don't want a more complicated vector library...

class V(tuple):
    '''A simple vector supporting scalar multiply and vector add'''
    def __new__ (cls, *args):
        return super(V, cls).__new__(cls, args)
    def __mul__(self,s):
        return V( *( c*s for c in self) )
    def __add__(self,s):
        return V( *( c[0]+c[1] for c in zip(self,s)) )
    def __repr__(self):
        return "V" + super(V, self).__repr__()

# As long as the "vector" is on the left it just works

xaxis = V(1.0, 0.0)
yaxis = V(0.0, 1.0)
print xaxis + yaxis      # => V(1.0, 1.0)
print xaxis*3 + yaxis*5  # => V(3.0, 5.0)
print 3*xaxis            # Broke, => (1.0, 0.0, 1.0, 0.0, 1.0, 0.0)

The "V" instances otherwise behave just like tuples. This requires that the "V" instances are all created with the same number of elements. You could add, for example, to __new__

if len(args)!=2: raise TypeError('Must be 2 elements')

to enforce that all the instances are 2d vectors....

Multiply the elements of a tuple in Python #

To multiply the elements of a tuple:

1. Use a generator expression to iterate over the tuple.
2. Multiply each tuple element by a number.
3. Use the tuple() class to convert the result to a tuple.

Copied!
import math

my_tuple = (5, 3)

by_five = tuple(5 * elem for elem in my_tuple)

print(by_five)  # 👉️ (25, 15)


# -----------------------------------------------

# ✅ multiply the elements of a tuple

my_tuple = (5, 5, 5)

result = math.prod(my_tuple)

print(result)  # 👉️ 125

# -----------------------------------------------

# ✅ multiply the elements of each tuple in a list

list_of_tuples = [(1, 2), (3, 4), (5, 6)]

result = [math.prod(tup) for tup in list_of_tuples]

# 👇️ [2, 12, 30]
print(result)

The first example uses a generator expression to multiply each element in a tuple by a certain number.

Copied!
my_tuple = (5, 3)

by_five = tuple(5 * elem for elem in my_tuple)

print(by_five)  # 👉️ (25, 15)

Generator expressions are used to perform some operation for every element or select a subset of elements that meet a condition.

On each iteration, we multiply the current tuple element by 5 and return the result.

The last step is to use the tuple() class to convert the generator object to a tuple.

Use the math.prod() method to multiply the elements of a tuple, e.g. result = math.prod(my_tuple). The math.prod method returns the product of all the elements in the provided iterable.

Copied!



import math
my_tuple = (5, 5, 5)
result = math.prod(my_tuple)
print(result) # 👉️ 125

Instead of multiplying each element in the tuple by a specific number, this example multiplies the elements in the tuple.

The math.prod method calculates the product of all the elements in the provided iterable.

The method takes the following 2 arguments:

If the iterable is empty, the start value is returned.

To multiply the elements of each tuple in a list:

1. Use a list comprehension to iterate over the list.
2. Use the math.prod() function to calculate the product of the elements in each tuple.

Copied!
import math

list_of_tuples = [(1, 2), (3, 4), (5, 6)]

result = [math.prod(tup) for tup in list_of_tuples]

# 👇️ [2, 12, 30]
print(result)

This example multiplies the values in each tuple in a list.

We used a list comprehension to iterate over the list.

List comprehensions are used to perform some operation for every element, or select a subset of elements that meet a condition.

On each iteration, we use the math.prod() function to calculate the product of the tuple's elements.

The final list contains the multiplication results for each tuple.

How do you multiply a tuple in Python?

How do you multiply a list by a scalar in Python?

How do you multiply a matrix by a scalar in Python?

Can you index a tuple?