Skip to main content

Python NumPy: How to Fix "RuntimeWarning: invalid value encountered in divide / divide by zero"

When performing element-wise division with NumPy arrays using numpy.divide() or the / operator, you might encounter RuntimeWarning: invalid value encountered in divide or RuntimeWarning: divide by zero encountered in divide. These warnings signal that one or more division operations involved problematic values, such as division by zero (x / 0), division of zero by zero (0 / 0), or division involving np.inf or np.nan. While NumPy often handles these by returning np.inf or np.nan and issuing a warning rather than raising an error that halts execution, it's crucial to understand why these warnings occur and how to manage them appropriately.

This guide will thoroughly explain the scenarios that trigger these division-related RuntimeWarnings in NumPy and provide clear solutions, primarily focusing on using numpy.seterr() or numpy.errstate() to control how NumPy handles such floating-point events, as well as the importance of inspecting your input arrays for problematic values like 0, np.inf, or np.nan.

Understanding NumPy's Division Warnings​

NumPy's behavior with exceptional floating-point operations (like division by zero) is configurable. By default, for operations like division:

  • Dividing a non-zero number by zero (e.g., 1 / 0) results in np.inf (infinity) or -np.inf and issues a RuntimeWarning: divide by zero encountered in divide.
  • Operations like 0 / 0, np.inf / np.inf, or any operation involving np.nan result in np.nan (Not a Number) and issue a RuntimeWarning: invalid value encountered in divide.

These are warnings, not errors that stop your program, because in many numerical contexts, inf and nan are valid outcomes that can be handled by subsequent operations or checks.

Reproducing the Warnings​

Let's look at examples that trigger these warnings.

Division by Zero (Non-Zero Numerator)​

import numpy as np

numerator_array_non_zero = np.array([10.0, 20.0, 30.0, 40.0])
denominator_array_with_zero = np.array([2.0, 0.0, 5.0, 0.0]) # Contains zero

# ⛔️ RuntimeWarning: divide by zero encountered in divide
# (This warning prints to stderr)
result_div_by_zero = np.divide(numerator_array_non_zero, denominator_array_with_zero)
# Or: result_div_by_zero = numerator_array_non_zero / denominator_array_with_zero

print("Result of division by zero (contains inf):")
print(result_div_by_zero)

Output:

Result of division by zero (contains inf):
[ 5. inf  6. inf]

Invalid Division (e.g., Zero by Zero)​

import numpy as np

numerator_array_with_zero = np.array([10.0, 0.0, 30.0])
denominator_array_also_zero = np.array([2.0, 0.0, 5.0]) # 0/0 at index 1

# ⛔️ RuntimeWarning: invalid value encountered in divide
# (This warning prints to stderr)
result_invalid_div = np.divide(numerator_array_with_zero, denominator_array_also_zero)

print("Result of invalid division (0/0 leads to nan):")
print(result_invalid_div)

Output:

Result of invalid division (0/0 leads to nan):
[ 5. nan  6.]

Division Involving np.inf or np.nan​

import numpy as np

arr_num = np.array([10.0, np.inf, 30.0, np.nan])
arr_den = np.array([2.0, np.inf, np.nan, 5.0])

# ⛔️ RuntimeWarning: invalid value encountered in divide (for inf/inf and operations with nan)
result_inf_nan_div = arr_num / arr_den

print("Result of division involving inf/nan:")
print(result_inf_nan_div)

Output:

Result of division involving inf/nan:
[ 5. nan nan nan]

Solution 1: Controlling Error Handling with numpy.seterr() (Global Setting)​

The numpy.seterr() function allows you to set how NumPy handles floating-point errors globally within your Python session or script. You can tell it to 'ignore', 'warn' (default for many), 'raise' (turn into an exception), 'call' (call a provided function), or 'print'.

To suppress the division warnings:

import numpy as np

# ✅ Globally ignore warnings/errors for division by zero and invalid operations
# This should be set at the beginning of your script or session.
np.seterr(divide='ignore', invalid='ignore')

numerator_array_non_zero = np.array([10.0, 20.0, 0.0])
denominator_array_with_zero = np.array([2.0, 0.0, 0.0])

# No warnings will be printed to stderr now
result_no_warning = np.divide(numerator_array_non_zero, denominator_array_with_zero)
print("Result with seterr(divide='ignore', invalid='ignore'):")
print(result_no_warning)

Output:

Result with seterr(divide='ignore', invalid='ignore'):
[ 5. inf nan]
note

This affects all subsequent NumPy operations in your current Python process until seterr() is called again.

Solution 2: Temporarily Controlling Error Handling with numpy.errstate() (Context Manager)​

If you only want to change NumPy's error handling behavior for a specific block of code, the numpy.errstate() context manager is the preferred approach. Settings revert to their previous state upon exiting the with block.

import numpy as np

numerator_array = np.array([10.0, 0.0])
denominator_array = np.array([0.0, 0.0])

print("Behavior before errstate (default warnings might occur):")
print(numerator_array / denominator_array) # Would warn

# ✅ Temporarily ignore division warnings within this block
with np.errstate(divide='ignore', invalid='ignore'):
    print("Inside errstate context (warnings ignored):")
    result_in_errstate = np.divide(numerator_array, denominator_array)
    print(result_in_errstate)

print("Behavior after errstate (reverted to default, warnings might occur again):")
print(numerator_array / denominator_array) # Would warn again if default is 'warn'

Output:

Behavior before errstate (default warnings might occur):
[inf nan]
Inside errstate context (warnings ignored):
[inf nan]
Behavior after errstate (reverted to default, warnings might occur again):
[inf nan]
note

This is safer than global np.seterr() as it limits the scope of the change.

Important: Inspecting Input Arrays for Problematic Values​

While suppressing warnings can be useful, it's often more critical to understand why the warnings are occurring by inspecting your input data.

Checking for Zeros in Divisor Array​

import numpy as np

denominator_array = np.array([2.0, 0.0, 5.0, 0.0])

if np.any(denominator_array == 0):
    print("Warning: Divisor array contains zeros. Division by zero will occur.")
    # You might then choose to:
    # - Replace zeros with a small number (epsilon) if appropriate: denominator_array[denominator_array == 0] = 1e-9
    # - Filter out rows/elements where division by zero would occur.
    # - Proceed and handle np.inf results later.

Output:

Warning: Divisor array contains zeros. Division by zero will occur.

Checking for np.inf or np.nan with np.isfinite()​

The numpy.isfinite() function tests element-wise for finiteness (i.e., not infinite and not Not a Number). .all() can check if all elements are finite.

import numpy as np

array1 = np.array([1.0, 2.0, np.inf, 4.0])
array2 = np.array([0.1, np.nan, 0.3, 0.4])

if not np.isfinite(array1).all():
    print(f"Array1 contains non-finite values (inf or nan): {array1}")

if not np.isfinite(array2).all():
    print(f"Array2 contains non-finite values (inf or nan): {array2}")

Output:

Array1 contains non-finite values (inf or nan): [ 1.  2. inf  4.]
Array2 contains non-finite values (inf or nan): [0.1 nan 0.3 0.4]
note

If non-finite values are present, you may need to clean your data (e.g., np.nan_to_num, np.clip, or imputation) before division if inf/nan results are not desired.

When is Ignoring the Warning Acceptable?​

Ignoring these RuntimeWarnings using np.seterr or np.errstate is acceptable if:

  • You fully understand that operations like 1/0 will produce np.inf and 0/0 will produce np.nan.
  • Your subsequent code is designed to correctly handle np.inf and np.nan values (e.g., using np.isinf(), np.isnan(), np.nan_to_num(), or functions that are NaN-aware like np.nansum()).
  • The occurrence of these warnings does not indicate a flaw in your input data or algorithm that should be addressed more directly.

Sometimes, especially in iterative algorithms or vectorized computations, allowing inf/nan to propagate and be handled at a later stage is more efficient than element-wise pre-checks.

Conclusion​

NumPy's RuntimeWarning for "invalid value encountered in divide" or "divide by zero encountered" serves as an alert to potentially problematic division operations.

  1. Understand the Cause: The warnings are due to divisions like x/0, 0/0, or operations involving np.inf/np.nan.
  2. Control Warning Behavior (If Necessary):
    • Use numpy.seterr(divide='ignore', invalid='ignore') for global suppression (use judiciously).
    • Prefer with np.errstate(divide='ignore', invalid='ignore'): for temporary, localized suppression within a specific code block.
  3. Inspect Data: Before suppressing warnings, check your divisor arrays for zeros and all input arrays for np.inf or np.nan to understand if data cleaning or algorithmic adjustment is needed.

By managing how NumPy handles these floating-point events and by being aware of your data's characteristics, you can write more robust and predictable numerical code.

Table of Contents