An error or exception is an unexpected event that occurs during program execution. It affects the flow of the program instructions which can terminate the program abnormally.
Responding or handling exceptions is called Exception Handling.
NumPy provides various ways to handle exceptions that occur during array operations.
Handle Floating-Point Errors in NumPy
In NumPy, the
seterr() function sets the way floating-point errors are handled.
It takes several parameters:
divide: specifies the behavior for division by zero or infinity
over: specifies the behavior for floating-point overflow
under: specifies the behavior for floating-point underflow
invalid: specifies the behavior for invalid floating-point operations such as 0/0, inf-inf, and sqrt(-1)
Note: Possible values of all these parameters are
"call". The default behavior for all types of errors is
Example 1: NumPy seterr() Function
import numpy as np # set behavior for division by zero to 'raise' np.seterr(divide='raise') # divide array1 by array2 array1 = np.array([1, 2, 3]) array2 = np.array([0, 2, 0]) result = np.divide(array1, array2) print(result)
FloatingPointError: divide by zero encountered in true_divide
In this example, we have set the behavior for division by zero errors to
This means when
np.divide() encounters division by zero during the calculation, it will raise the
If we had set the behavior for division by zero to
divide='ignore'- it doesn't raise an error or print a warning message and the output would be
[inf 1. inf]
divide='warn'- it prints a warning message and also runs the program and the output would be
[inf 1. inf]
Example 2: The over Parameter in NumPy seterr() Function
import numpy as np # set behavior for floating-point overflow to 'raise' np.seterr(over='raise') calc1 = np.exp(1000) print(calc1)
FloatingPointError: overflow encountered in exp
In the above example, we set the behavior for floating-point overflow to
We then calculated
np.exp(1000), which results in a floating-point overflow because the result of the calculation is too large to be represented by the floating-point data type.
This raises an exception:
FloatingPointError: overflow encountered in exp.
Note: If we set
np.seterr(under='raise') and calculate
np.exp(-1000), this raises an exception:
FloatingPointError: underflow encountered in exp.
Example 3: The invalid Parameter in NumPy seterr() Function
In Numpy, we can use the
invalid parameter in
seterr() to raise an exception when an invalid floating-point operation occurs. For example,
import numpy as np # set the invalid parameter to 'raise' np.seterr(invalid='raise') # try taking the square root of a negative number x = np.sqrt(-1) # Output: FloatingPointError: invalid value encountered in sqrt
Here, we attempted to take the square root of -1, which is an invalid floating-point operation.
As we have set the
invalid='raise', NumPy will raise a
NumPy try-catch Block
We can use the
try...except block in NumPy to handle an error. Here's the syntax of
try: # code that may cause exception except: # code to run when exception occurs
Here, we have placed the code that could potentially raise an exception within the
try block. When an exception occurs in the
try block, it's caught by the
except block must work together to handle the exception.
Let's see an example.
import numpy as np array1 = np.array([1, 4, 3]) array2 = np.array([0, 2, 0]) # try to divide the arrays try: result = array1/array2 except ZeroDivisionError as e: print("Error: Cannot divide by zero")
runtimewarning: divide by zero encountered in divide