Multiply each element in a List by a Number in Python

# Table of Contents

1. Multiply each element in a List by a Number in Python
2. Multiply all elements in a List in Python
3. Multiply two lists element-wise in Python

# Multiply each element in a list by a number in Python

To multiply each element in a list by a number:

1. Use a list comprehension to iterate over the list.
2. On each iteration, multiply the current element by the number.
3. The new list will contain the multiplication results.

Copied!
# ✅ Multiply each element in a list by a number
import math

my_list = [2, 4, 6]

result = [item * 10 for item in my_list]
print(result)  # 👉️ [20, 40, 60]

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

# ✅ Multiply all elements in a list

my_list = [2, 4, 6]

result = math.prod(my_list)
print(result)  # 👉️ 48

We used a list comprehension to iterate over the list and multiplied each list item by 10.

On each iteration, we multiply the current list item by the specified number and return the result.

Alternatively, you can use a simple for loop.

# Multiply each element in a list by a number using a for loop

This is a four-step process:

1. Declare a new variable that stores an empty list.
2. Use a for loop to iterate over the original list.
3. On each iteration, multiply the current list item by the number.
4. Append the result to the new list.

Copied!
my_list = [2, 4, 6]

result = []

for item in my_list:
    result.append(item * 10)

print(result) # 👉️ [20, 40, 60]

The for loop works in a very similar way to the list comprehension, but instead of returning the list items directly, we append them to a new list.

# Multiply each element in a list by a number using map()

You can also use the map() function to multiply each element in a list.

Copied!
my_list = [2, 4, 6]

result = list(map(lambda item: item * 10, my_list))

print(result)  # 👉️ [20, 40, 60]

The map() function takes a function and an iterable as arguments and calls the function with each item of the iterable.

The last step is to use the list() class to convert the map object to a list.

# Multiply each element in a list by a number using NumPy

If you work with NumPy arrays, you can directly use the multiplication operator on the array to multiply each of its elements by a number.

Copied!
import numpy as np


arr = np.array([2, 4, 6])

result = arr * 10

print(result)  # 👉️ [20 40 60]

Note that this only works with NumPy arrays. If you multiply a Python list by a number, it gets repeated N times.

Copied!
print([2, 4, 6] * 2) # 👉️ [2, 4, 6, 2, 4, 6]

Multiplying a Python list by N returns a new list containing the elements of the original list repeated N times.

# Multiply all elements in a List in Python

If you need to multiply all elements in a list, use the math.prod() function.

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

Copied!
import math

my_list = [2, 3, 5]

result = math.prod(my_list)
print(result)  # 👉️ 30

Make sure to import the math module at the top.

We used the math.prod method to multiply all the elements in a list.

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

Copied!
import math

my_list = [5, 5, 5]

result = math.prod(my_list)

print(result) # 👉️ 125

The method takes the following 2 arguments:

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

Alternatively, you can use the reduce() function.

# Multiply all elements in a List using reduce()

This is a two-step process:

1. Pass a lambda function and the list to the reduce() function.
2. The lambda function should take the accumulator and the current value and should return the multiplication of the two.

Copied!
from functools import reduce


my_list = [2, 3, 5]

result = reduce(lambda x, y: x * y, my_list)
print(result) # 👉️ 30

The reduce() function takes the following 3 parameters:

If we provide a value for the initializer argument, it is placed before the items of the iterable in the calculation.

Copied!
from functools import reduce

my_list = [2, 3, 5]

def do_math(acc, curr):
    print(acc)  # 👉️ is 10 on first iteration
    return acc * curr

result = reduce(do_math, my_list, 10)
print(result)  # 👉️ 300

We passed 10 for the initializer argument, so the value of the accumulator will be 10 on the first iteration.

If the iterable is empty and the initializer is provided, the initializer is returned.

If the initializer is not provided and the iterable contains only 1 item, the first item is returned.

Copied!
from functools import reduce

my_list = [2]

result = reduce(lambda acc, curr: acc * curr, my_list)
print(result)  # 👉️ 2

# Multiply all elements in a List using a for loop

You can also use a for loop to multiply all elements in a list.

Copied!
my_list = [2, 3, 5]


result = 1

for item in my_list:
    result = result * item

print(result) # 👉️ 30

On each iteration of the for loop, we multiply the result variable by the current list item and reassign it to the result.

# Multiply two lists element-wise in Python

To multiply two lists element-wise:

1. Use the zip function to get an iterable of tuples with the corresponding items.
2. Use a list comprehension to iterate over the iterable.
3. On each iteration, multiply the values in the current tuple.

Copied!
list_1 = [1, 2, 3]
list_2 = [4, 5, 6]

# 👇️ [(1, 4), (2, 5), (3, 6)]
print(list(zip(list_1, list_2)))

result = [x * y for x, y in zip(list_1, list_2)]

print(result)  # 👉️ [4, 10, 18]

The zip() function iterates over several iterables in parallel and produces tuples with an item from each iterable.

Copied!
list_1 = [1, 2, 3]
list_2 = [4, 5, 6]

# 👇️ [(1, 4), (2, 5), (3, 6)]
print(list(zip(list_1, list_2)))

You can imagine that the zip() function iterates over the lists, taking 1 item from each.

The last step is to use a list comprehension to iterate over the zip object and multiply the values in each tuple.

Copied!
list_1 = [1, 2, 3]
list_2 = [4, 5, 6]

# 👇️ [(1, 4), (2, 5), (3, 6)]
print(list(zip(list_1, list_2)))

result = [x * y for x, y in zip(list_1, list_2)]

print(result)  # 👉️ [4, 10, 18]

On each iteration, we unpack the values from the tuple and use the multiplication * operator to multiply them.

Copied!
a, b = (2, 5)

print(a * b) # 👉️ 10

# Multiplying more than two lists element-wise

You can also use this approach to multiply more than two lists element-wise.

Copied!
list_1 = [1, 2, 3]
list_2 = [4, 5, 6]
list_3 = [7, 8, 9]

# 👇️ [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
print(list(zip(list_1, list_2, list_3)))

result = [x * y * z for x, y, z in zip(list_1, list_2, list_3)]

print(result)  # 👉️ [28, 80, 162]

Alternatively, you can use the map() function.

# Multiply two lists element-wise using map()

This is a two-step process:

1. Use the map() function to call the mul() function with the two lists.
2. Use the list() class to convert the map object to a list.

Copied!
from operator import mul

list_1 = [1, 2, 3]
list_2 = [4, 5, 6]

result = list(map(mul, list_1, list_2))

print(result)  # 👉️ [4, 10, 18]

The map() function takes a function and an iterable as arguments and calls the function with each item of the iterable.

The mul function from the operator module is the same as a * b.

The map function returns a map object, so we had to use the list() class to convert the result to a list.

# Additional Resources

You can learn more about the related topics by checking out the following tutorials:

• Get the first character of each string in a List in Python