NumPy power() Function

---

---

The NumPy power() function is used to raise each element of an array to the power of a corresponding element in another array, or a scalar.

It performs element-wise exponentiation, returning a new array of the results. You can also raise an array to a scalar power. This function handles broadcasting for arrays of different shapes.

Syntax

Following is the syntax of the NumPy power() function −

numpy.power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Parameters

This function accepts the following parameters −

• x1: The base input array. Both arrays should have the same shape, or they must be broadcastable to a common shape.
• x2: The exponent input array. Like x1, it should have the same shape as x1, or be broadcastable to a common shape.
• out (optional): A location into which the result is stored. If provided, it must have a shape that the inputs broadcast to. If not provided or None, a freshly-allocated array is returned.
• where (optional): This condition is broadcast over the input. At locations where the condition is True, the out array will be set to the ufunc result. Otherwise, it will retain its original value.
• casting (optional): Controls what kind of data casting may occur. Defaults to 'same_kind'.
• order (optional): Controls the memory layout order of the result. 'C' means C-order, 'F' means Fortran-order, 'A' means 'F' if inputs are all F, 'C' otherwise, 'K' means match the layout of the inputs as closely as possible.
• dtype (optional): The type of the returned array and of the accumulator in which the elements are raised to power. The dtype of x1 and x2 is used by default unless dtype is specified.
• subok (optional): If True, then sub-classes will be passed-through, otherwise the returned array will be forced to be a base-class array.

Return Value

This function returns the element-wise power of the input arrays x1 and x2. If out is provided, it returns a reference to out.

Example: Basic Usage of power() Function

In the following example, we create two 1-dimensional arrays and use the power() function to perform element-wise exponentiation −

import numpy as np

# Creating two 1-dimensional arrays
arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([2, 3, 2, 1])

# Performing element-wise power
result = np.power(arr1, arr2)
print(result)

Following is the output obtained −

[ 1 8 9 4] 

Example: Power with Broadcasting

In this example, we demonstrate the use of broadcasting with the power() function. We create a 2-dimensional array and raise it to the power of a 1-dimensional array −

import numpy as np

# Creating a 2-dimensional array
arr1 = np.array([[1, 2, 3], [4, 5, 6]])

# Creating a 1-dimensional array
arr2 = np.array([2, 3, 2])

# Performing element-wise power with broadcasting
result = np.power(arr1, arr2)
print(result)

This will produce the following result −

[[  1   8   9]
 [ 16 125  36]]

Example: Raising an Array to a Scalar Power

In this example, we raise all elements of an array to the power of a scalar −

import numpy as np

# Creating a 1-dimensional array
arr = np.array([2, 3, 4])

# Raising the array to the power of 3
result = np.power(arr, 3)
print(result)

Following is the output of the above code −

[ 8 27 64]

Example: Power with Negative Exponent

In this example, we raise the array elements to a negative exponent, which results in reciprocal values −

import numpy as np

# Creating a 1-dimensional array
arr = np.array([2, 4, 8], dtype=float)

# Raising the array to the power of -1
result = np.power(arr, -1)
print(result)

The output obtained is as shown below −

[0.5   0.25  0.125]