# Python List Multiply

You can use different approaches of Python to multiply list elements in Python. One of the approaches is multiplying each element of a list by a number and another one is multiplying two lists element-wise. You can multiply Python lists using some more approaches like the for loops, list comprehensions, the `zip()` function, and the `np.multiply()` function from NumPy. In this article, I will explain the list multiply by using all these approaches with examples.

## 1. Quick Examples of Multiplying List Elements

If you are in a hurry, below are some quick examples of multiplying list elements.

``````
# Quick examples of multiplying lists

# Example 1: Multiply list
# Using for loop
mylist = [2, 4, 6, 8]
multiplied = []
for number in mylist:
multiplied.append(number * 2)

# Example 2: Using list comprehension
mylist = [1, 3, 5, 7]
multiplied = [element * 3 for element in mylist]

# Example 3: Multiply the list
# Using Numpy
mylist = [2, 5, 4, 7]
array = np.array(mylist) * 2
multiplied = list(array)

# Example 4: Multiply two lists
# Using for loop and zip() function
list1 = [2, 4, 6, 8]
list2 = [3, 7, 2, 5]
multiplied = []
for elem1, elem2 in zip(list1, list2):
multiplied.append(elem1 * elem2)

# Example 5: Multiply two lists
# Using list comprehension and Zip() function
list1 = [2, 4, 6, 8]
list2 = [3, 7, 2, 5]
multiplied = [elem1 * elem2 for elem1, elem2 in zip(list1, list2)]

# Example 6: Multiply two lists using numpy
list1 = [2, 4, 6, 8]
list2 = [3, 7, 2, 5]
multiplied = list(np.multiply(list1, list2))
``````

## 2. Multiply the List Using For Loop

You can multiply each element of a list by a specific value(scalar), using a for loop. For example, first, initialize the list of values named` mylist` and then create an empty list named `multiplied`. You can use for loop to iterate over each element in the list. For every iteration, each element `mylist` is multiplied by 2 and appended to the empty list using the append() function. Finally, you can print the `multiplied` list, which contains the elements `[4, 8, 12, 16]` obtained by multiplying each element of the original list by `2`.

``````
# Initialize list
mylist = [2, 4, 6, 8]
print("Original list: ",mylist)

# Multiply list
# Using for loop
multiplied = []
for number in mylist:
multiplied.append(number * 2)
print("After multiplying the list is:", multiplied)
``````

Yields below output.

## 3. Multiply the List Using List Comprehension

Alternatively, you can use list comprehension to multiply each element of a list by a specific value. For example, you have an original list `mylist` containing [1,3,5,7]. Then, using list comprehension, you can create a new list `multiplied` by multiplying each element of the original list by `3`. Finally, you can print the `multiplied` list, which contains the elements `[3, 9, 15, 21]` obtained by multiplying each element of the original list by `3`.

``````
# Initialize list
mylist = [1, 3, 5, 7]
print("Original list: ",mylist)

# Using list comprehension
multiplied = [element * 3 for element in mylist]
print("After multiplying list is:", multiplied)
``````

Yields below output.

## 4. Multiply the List Using Numpy

Similarly, you can use NumPy to multiply each element of a Python list by a specific value. For example, you have an original list `mylist `containing `[2, 5, 4, 7]`. Then, using `np.array(mylist)`, you can convert the list into a NumPy array. Next, you can multiply the NumPy array by `2` using the `*` operator, which performs element-wise multiplication. The result is stored in the `array` variable.

Finally, you can convert the array back to a regular Python list using `list(array)` and assign it to the multiplied variable. The `multiplied` list contains the elements `[4, 10, 8, 14]`, which are the original list elements multiplied by `2`.

``````
import numpy as np

# Initialize list
mylist = [2, 5, 4, 7]
print("Original list: ",mylist)

# Multiply list using numpy
array = np.array(mylist) * 2
multiplied = list(array)
print("After multiplying the list:", multiplied)

# Output:
# Original list:  [2, 5, 4, 7]
# After multiplying the list: [4, 10, 8, 14]
``````

## 5. Multiply Two Lists Using For Loop and Zip()

You can multiply two lists element-wise using a `for loop` and the zip() function in Python.You can iterate over the corresponding elements of the two lists and perform the multiplication.

In the below example, you have two lists, `list1` and `list2`, with corresponding elements `[2, 4, 6, 8]` and `[3,7,2,5]`, respectively. You can use a for loop together with the `zip(`) function to iterate over the corresponding elements of the two lists simultaneously. The `zip()` function pairs up the elements from `list1` and `list2`, creating an iterable that you can iterate over in the loop. Inside the loop, you multiply each pair of elements `(elem1 * elem2) `and append the result to the multiplied list.

``````
# Initialize lists
list1 = [2, 4, 6, 8]
list2 = [3, 7, 2, 5]

# Multiply two lists
# Using for loop and zip() function
multiplied = []
for elem1, elem2 in zip(list1, list2):
multiplied.append(elem1 * elem2)
print("After multiplying the two list:", multiplied)

# Output:
# After multiplying the two list: [6, 28, 12, 40]
``````

## 6. Using List Comprehension and Zip() Function

To multiply two lists element-wise using list comprehension and the `zip()` function in Python. For example, you have two lists, `list1` and `list2`, with corresponding elements `[2, 4, 6, 8] `and `[3, 2, 1, 5]`, respectively. Using list comprehension, you can iterate over the corresponding elements of `list1` and `list2` simultaneously using the `zip() `function.

The `zip()` function pairs up the elements from the two lists, creating an iterable that you can iterate over in the list comprehension. Within the list comprehension, you multiply each pair of elements `(elem1 * elem2)` and store the result directly in the multiplied list.

``````
# Initialize lists
list1 = [2, 4, 6, 8]
list2 = [3, 7, 2, 5]

# Multiply two lists
# Using list comprehension and Zip() function
multiplied = [elem1 * elem2 for elem1, elem2 in zip(list1, list2)]
print("After multiplying the two list:", multiplied)
``````

Yields the same output as above.

## 7. Multiply Two Lists Element-Wise Using Numpy

Alternatively, to perform multiplication over the two lists element-wise, you can utilize the power of NumPy arrays and their element-wise operations.

In the below example, you have two lists `list1` containing `[2, 4, 6, 8]` and `list2` containing `[3, 7, 2, 5]`. By using `np.multiply(list1, list2)`, you can multiply the corresponding elements of the two lists using NumPy’s multiply function. The resulting array is then converted back to a Python list using the list() function and assigned to the multiplied variable.

``````
import numpy as np

# Initialize lists
list1 = [2, 4, 6, 8]
list2 = [3, 7, 2, 5]

# Multiply two lists using numpy
multiplied = list(np.multiply(list1, list2))
print("After multiplying the two list:", multiplied)
``````

Yields the same output as above.

## 8. Conclusion

In this article, I have explained the different approaches of Python to perform multiplication over the lists by using the for loop, list comprehension, `numpy` module, and `zip()` functions.

Happy Learning !!

### Malli

I am Mallikarjuna an experienced technical writer with a passion for translating complex Python concepts into clear, concise, and user-friendly documentation. Over the years, I have written hundreds of articles in Pandas, NumPy, Python, and I take pride in my ability to bridge the gap between technical experts and end-users by delivering well-structured, accessible, and informative content.