How to catch OverflowError Exception in Python?

When an arithmetic operation exceeds the limits of the variable type, an OverflowError is raised. This commonly occurs with floating-point calculations that produce results too large for Python to represent. While integers in Python 3 have arbitrary precision, floating-point operations can still overflow.

Using try-except to Catch OverflowError

You can use a try-except block to catch an OverflowError and prevent your program from crashing when a calculation overflows ?

Example: Catching an OverflowError

In this example, we calculate a very large exponent which causes an OverflowError ?

try:
    result = 10.0 ** 1000
    print("Result:", result)
except OverflowError:
    print("OverflowError caught: number too large.")

OverflowError caught: number too large.

Capturing the Exception Object

You can also capture the exception object to get more details about the error. This allows you to access the specific error message ?

Example

try:
    result = 2.0 ** 10000
    print("Result:", result)
except OverflowError as e:
    print("Caught OverflowError:", e)

Caught OverflowError: (34, 'Numerical result out of range')

When does OverflowError Occur?

OverflowError usually happens when floating-point calculations result in numbers too large for Python to handle. Common scenarios include exponential functions with large arguments ?

Example with Math Functions

import math

try:
    result = math.exp(1000)
    print("Result:", result)
except OverflowError as e:
    print("OverflowError caught:", e)

OverflowError caught: math range error

Handling OverflowError in Calculations

To prevent program termination due to overflow, catch the exception and provide fallback behavior such as returning infinity or alternative values ?

Example with Safe Function

import math

def safe_exp(x):
    try:
        return math.exp(x)
    except OverflowError:
        return float('inf')

# Test with normal and overflow values
print("Normal value:", safe_exp(5))
print("Overflow value:", safe_exp(1000))

Normal value: 148.4131591025766
Overflow value: inf

Multiple Exception Handling

You can handle OverflowError alongside other mathematical exceptions for robust error handling ?

import math

def safe_calculation(x, y):
    try:
        result = x ** y + math.exp(x)
        return result
    except OverflowError:
        return "Overflow: Result too large"
    except ValueError:
        return "Value error: Invalid input"
    except ZeroDivisionError:
        return "Division by zero error"

print(safe_calculation(10, 5))    # Normal calculation
print(safe_calculation(10, 1000)) # Causes overflow

122026.4658129
Overflow: Result too large

Conclusion

Use try-except blocks to catch OverflowError when performing large arithmetic operations. This prevents program crashes and allows you to handle overflow gracefully with fallback values or error messages.