numpy.multiply() in Python

The numpy.multiply() is a numpy function in Python which is used to find element-wise multiplication of two arrays or scalar (single value). It returns the product of two input array element by element.

Syntax:

numpy.multiply(arr1, arr2, out=None, where=True, casting='same_kind', order='K', dtype=None, subok=True)

Parameters:

• arr1 (array_like or scalar): First input array.
• arr2 (array_like or scalar): Second input array.
• dtype (optional): Desired type of the returned array. By default dtype of arr1 is used.
• out (optional, ndarray): A location where result is stored. If not provided a new array is created.
• where (optional, array_like): A condition to find where multiplication should happen. If True multiplication occurs at that position and if False value in output remains unchanged.

Return: ndarray (Element-wise product of arr1 and arr2).

Example 1: Multiplying a Scalar with a scalar

• out_num = geek.multiply(in_num1, in_num2): Multiplies in_num1andin_num2 using multiply and stores the result in out_num.

import numpy as geek
in_num1 = 4
in_num2 = 6
print ("1st Input  number : ", in_num1)
print ("2nd Input  number : ", in_num2)
out_num = geek.multiply(in_num1, in_num2) 
print ("output number : ", out_num) 

Output:

Example 2: Multiplying a Scalar with an Array

When one of the inputs is a scalar it is multiplied with each element of the array. This operation is commonly used for scaling or adjusting values in an array. Here Scalar value 5 is multiplied with each element 1,2,3.

import numpy as geek
in_arr = geek.array([1, 2, 3])
scalar_value = 5

result_arr = geek.multiply(in_arr, scalar_value)
print(result_arr)

Output:

[ 5 10 15]

Example 3: Element-wise Multiplication of Arrays

When both inputs are arrays of the same shape numpy.multiply() multiplies corresponding elements together. This operation is performed element by element.

import numpy as geek
in_arr1 = geek.array([[2, -7, 5], [-6, 2, 0]])
in_arr2 = geek.array([[0, -7, 8], [5, -2, 9]])
print ("1st Input array : ", in_arr1)
print ("2nd Input array : ", in_arr2)
out_arr = geek.multiply(in_arr1, in_arr2) 
print ("Resultant output array: ", out_arr) 

Output

In above example corresponding elements from in_arr1 and in_arr2 are multiplied:

• 2 * 0 = 0
• -7 * -7 = 49
• 5 * 8 = 40
• -6 * 5 = -30
• 2 * -2 = -4
• 0 * 9 = 0

Example 4: Multiplying Arrays with Different Shapes (Broadcasting)

numpy.multiply() supports broadcasting which means it can multiply arrays with different shapes as long as they are compatible for broadcasting rules.

import numpy as geek
in_arr1 = geek.array([1, 2, 3])
in_arr2 = geek.array([[4], [5], [6]])

result_arr = geek.multiply(in_arr1, in_arr2)
print(result_arr)

Output:

In this example in_arr1 is broadcasted to match the shape of in_arr2 for element-wise multiplication.

To understand broadcasting you can refer to this article: NumPy Array Broadcasting

Example 5: Using out Parameter

We can specify an output array where result of the multiplication will be stored. This avoids creating a new array and can help save memory when working with large datasets.

import numpy as geek
in_arr1 = geek.array([1, 2, 3])
in_arr2 = geek.array([4, 5, 6])
output_arr = geek.empty_like(in_arr1)
geek.multiply(in_arr1, in_arr2, out=output_arr)
print(output_arr)

Output:

[ 4 10 18]

Result of element-wise multiplication is stored in output_arr instead of creating a new array. By mastering numpy.multiply() we can efficiently handle element-wise multiplication across arrays and scalars.