NumPy power(): Element-Wise Exponents, Broadcasting, and Dtypes

Quick answer: Use np.power(base, exponent) or the ** operator for element-wise array powers. Make broadcasting, negative exponents, fractional domains, dtype, and where or out behavior explicit before relying on the result.

NumPy power infographic showing base and exponent arrays, broadcasting, negative power domains, dtype, out, and where — np.power is element-wise: shapes, domains, dtype, and masked output define the result.

numpy.power() raises base values to exponent values element by element. It works with scalars, lists, and arrays, and it follows NumPy broadcasting rules.

The official NumPy documentation covers numpy.power(), numpy.float_power(), and numpy.square().

Use np.power(base, exponent) when bases or exponents are array-like. Use the ** operator for simple expressions when it is clearer. Use np.square() when the exponent is exactly two and readability matters.

Dtype behavior matters. Integer bases with negative integer exponents raise a ValueError because the result would be fractional. Convert to float or use np.float_power() when negative powers are expected.

Negative bases with non-integer exponents produce nan for real dtype inputs. Use a complex dtype when the complex-valued result is the intended result.

Broadcasting allows a scalar exponent to apply to every base, or an exponent array to align with a base array. Check shapes when the result is not what you expected.

The function is a NumPy ufunc, so it supports the usual ufunc behavior such as element-wise operation, broadcasting, and dtype-dependent output. That makes it much more convenient than writing loops for arrays.

When examples combine integers, floats, and complex values, make dtype choices explicit. The same mathematical expression can produce an error, nan, or a complex result depending on the dtype.

For code reviews, look for three common traps: integer arrays raised to negative powers, shape pairs that do not broadcast, and negative real bases raised to fractional powers.

In data workflows, decide whether exponent output should stay integer, become floating-point, or become complex. Making that decision before the calculation keeps later comparisons, serialization, and plotting steps predictable.

Contents

Raise An Array To One Exponent

A scalar exponent applies to every element.

import numpy as np

values = np.array([2, 3, 4])

result = np.power(values, 2)

print(result)

Each value is squared.

The result has the same shape as the input array.

For square-only code, np.square(values) is an equivalent option.

np.square() can be clearer in performance-sensitive or heavily reviewed code because it states the exact operation.

Use Element-Wise Exponents

The exponent can be an array with a compatible shape.

import numpy as np

bases = np.array([2, 3, 4])
exponents = np.array([1, 2, 3])

result = np.power(bases, exponents)

print(result)

Each base is paired with the exponent at the same position.

This is useful when each value needs a different exponent.

The arrays must be broadcastable to a common shape.

If the shapes are identical, every position is paired directly. If the shapes differ, NumPy applies broadcasting rules before calculating the result.

Python Pool infographic showing NumPy bases, exponents, arrays, and elementwise power — Base values: NumPy bases, exponents, arrays, and elementwise power.

Broadcast Bases And Exponents

Broadcasting can combine a column of bases with a row of exponents.

import numpy as np

bases = np.array([[2], [3], [4]])
exponents = np.array([1, 2, 3])

result = np.power(bases, exponents)

print(result)

The output shape is formed by broadcasting the inputs.

This creates a small table of powers.

Use this pattern deliberately because broadcasting mistakes can create larger arrays than expected.

This table-style pattern is useful for comparing several exponents across the same set of bases.

When broadcasting creates a table, print the output shape during development so a small input does not accidentally expand into a large intermediate array.

Handle Negative Integer Powers

Integer bases with negative integer exponents raise an error.

import numpy as np

values = np.array([2, 4, 8])

try:
    print(np.power(values, -1))
except ValueError as error:
    print(type(error).__name__)

The result would contain fractions, but the integer dtype cannot represent them.

Convert the base values to float or use float_power() when negative powers are expected.

This is a common source of confusing examples in older tutorials.

If you see this error in real code, inspect the dtype before changing the formula. The math may be fine while the integer dtype is the issue.

Python Pool infographic mapping paired bases and exponents through np.power to an output array — Raise values: Paired bases and exponents through np.power to an output array.

Use float_power For Negative Exponents

float_power() promotes inputs to floating-point results.

import numpy as np

values = np.array([2, 4, 8])

result = np.float_power(values, -1)

print(result)

This returns reciprocal values as floats.

Use this form when fractional output is expected.

It makes the dtype conversion explicit in the code.

Python Pool infographic comparing scalar, vector, matrix, broadcasting, dtype, and output shape — Broadcast exponents: Scalar, vector, matrix, broadcasting, dtype, and output shape.

Use Complex dtype For Fractional Powers

Negative real bases with fractional powers need complex dtype when complex output is intended.

import numpy as np

real_values = np.array([-4.0, -9.0])
complex_values = real_values.astype(complex)

with np.errstate(invalid="ignore"):
    print(np.power(real_values, 0.5))
print(np.power(complex_values, 0.5))

The real input produces nan values for square roots of negative numbers.

The complex input returns complex results.

Use this behavior deliberately. If complex output would surprise downstream code, validate the base values before applying fractional exponents.

In short, use np.power() for element-wise exponents, rely on broadcasting only when shapes are intentional, choose float_power() for negative powers that should be fractional, and use complex dtype when fractional powers of negative bases are meaningful.

Element-Wise Powers And Broadcasting

np.power() raises each base to the corresponding exponent. Scalar exponents apply to every element, while array bases and exponents must be broadcastable to a common shape. The ** operator is a convenient shorthand for ndarray powers, but the ufunc form exposes options such as where, out, and dtype.

import numpy as np

bases = np.array([2, 3, 4])
exponents = np.array([1, 2, 3])

print(np.power(bases, exponents))
print(bases ** 2)

matrix = np.array([[2, 3], [4, 5]])
print(np.power(matrix, np.array([1, 2])))

Python Pool infographic testing zero, negative bases, fractional exponents, overflow, and casting — Power checks: Zero, negative bases, fractional exponents, overflow, and casting.

Negative And Fractional Exponents

An integer base raised to a negative integer exponent is not represented as an integer result and can raise ValueError. Negative real bases raised to non-integral powers can produce nan with a warning. If a complex result is mathematically intended, cast the input to a complex dtype instead of silently accepting an invalid real-domain result.

Control Dtype, out, And where

Choose dtype when the output domain matters, and supply an initialized out array when reusing storage. With where, locations where the condition is false retain the existing out values; an uninitialized output can therefore contain uninitialized values at those positions. Treat this as a data contract, not a cosmetic optimization.

For exponent and root operations, compare Python power syntax with NumPy square roots. Read python power and numpy square root for the related workflow.