Skip to main content

How to Resolve Python "ZeroDivisionError: division by zero"

The ZeroDivisionError is a common arithmetic error in Python that occurs when you attempt to divide a number or perform a modulo operation with zero as the divisor (the second operand). This is mathematically undefined, so Python raises this error to prevent nonsensical results. You might see variations like ZeroDivisionError: float division by zero, ZeroDivisionError: integer division by zero, or ZeroDivisionError: integer modulo by zero.

This guide explains why division/modulo by zero is problematic and provides standard Pythonic ways to prevent or handle this error.

Understanding the Error: Mathematical Impossibility​

Division by zero is undefined in standard mathematics. As a number gets closer and closer to zero, dividing another number by it results in a value approaching positive or negative infinity. Since computers cannot typically represent infinity directly in integer arithmetic and doing so in floating-point arithmetic can lead to non-numerical results (inf, nan), programming languages like Python explicitly forbid division or modulo operations where the divisor/modulus is zero, raising an error instead.

Common Causes​

Direct Division/Modulo by Zero Literal (/ 0, // 0, % 0)​

Directly using 0 as the second operand for /, //, or %.

numerator = 10

# Error Scenarios
try:
    result = numerator / 0  # ⛔️ ZeroDivisionError: float division by zero (or division by zero if numerator is int)
except ZeroDivisionError as e: 
    print(e)

try:
    result = numerator // 0 # ⛔️ ZeroDivisionError: integer division or modulo by zero
except ZeroDivisionError as e: 
    print(e)

try:
    result = numerator % 0  # ⛔️ ZeroDivisionError: integer division or modulo by zero
except ZeroDivisionError as e:
     print(e)

Variable Holding Zero Used as Divisor/Modulus​

More commonly, a variable used as the divisor or modulus holds the value 0 at runtime.

numerator = 100.0
divisor = 0 # Variable holds zero

# Error Scenario
try:
    # ⛔️ ZeroDivisionError: float division by zero
    result = numerator / divisor
    print(result)
except ZeroDivisionError as e:
    print(f"Error: {e}")

Potential Sources of Zero Values​

A variable might unexpectedly become zero due to:

  • User input where the user types '0'.
  • Calculations resulting in zero (e.g., x = 5 - 5).
  • Default values (e.g., int() returns 0).
  • Data read from files or APIs containing zero.
  • Loop counters or indices reaching zero inappropriately.
  • Integer conversion of small floats (int(0.9) is 0).

The safest approach is to explicitly check if the divisor/modulus is non-zero before performing the operation.

Example with Division:

numerator = 50
divisor = 0 # Here a constant, but it could be from user input or other calculation

result = None # Initialize result variable

# Check if divisor is not zero
if divisor != 0:
    result = numerator / divisor
    print(f"Calculation result: {result}")
else:
    # Handle the zero case explicitly
    print("Error: Cannot divide by zero. Setting result to default.")
    result = 0 # Or float('inf'), None, or raise a custom error, etc.

print(f"Final result: {result}") # Output: 0

Output:

ERROR!
Error: Can not divide by zero. Setting result to default.
Final result: 0

Example with Modulo:

dividend = 23
modulus = 0
remainder = None

if modulus != 0:
    remainder = dividend % modulus
    print(f"Remainder: {remainder}")
else:
    print("Error: Cannot perform modulo by zero.")
    remainder = "Undefined" # Example handling

print(f"Final remainder: {remainder}") # Output: Undefined

Output:

ERROR!
Error: Can not perform modulo by zero.
Final remainder: Undefined

This "Look Before You Leap" (LBYL) approach clearly handles the division-by-zero case based on your application's requirements.

Solution 2: Use a try...except ZeroDivisionError Block​

Alternatively, you can attempt the operation and catch the specific ZeroDivisionError if it occurs. This is known as "Easier to Ask for Forgiveness than Permission" (EAFP).

numerator = 50.0
divisor = 0
result = None # Initialize

print("Attempting division with try/except...")
try:
    # Attempt the division
    result = numerator / divisor
    print(f"Division successful: {result}") # This won't run
except ZeroDivisionError:
    # Handle the specific error if divisor was zero
    print("Caught ZeroDivisionError: Cannot divide by zero.")
    result = 0 # Assign a default value
except Exception as e:
    # Catch other potential errors
    print(f"Caught unexpected error: {e}")

print(f"Final result after try/except: {result}") # Output: 0

This approach keeps the main logic cleaner if division by zero is considered an exceptional case rather than a common possibility.

Specific Error Messages​

The exact wording of the ZeroDivisionError depends slightly on the types involved and the operator:

  • float division by zero: Occurs with / when at least one operand is a float (or when / is used between two integers in Python 3, as / always produces a float).
  • division by zero: Can occur with / between integers in older Python versions or potentially in specific contexts.
  • integer division or modulo by zero: Occurs with // (floor division) or % (modulo) when the divisor/modulus (b in a // b or a % b) is an integer 0.
  • float modulo by zero: Occurs with % when the modulus (b in a % b) is 0 or 0.0 and a is a float.
note

The solution (check before operation or use try/except) is the same regardless of the specific message.

Debugging: Finding the Source of Zero​

If you get this error unexpectedly, the crucial step is to find out why the divisor/modulus variable is zero.

  • Print Values: Add print() statements immediately before the failing line to inspect the values of the variables involved. 
    print(f"DEBUG: Numerator={numerator}, Divisor={divisor}")
    # Failing line:
    # result = numerator / divisor
  • Trace Backwards: Examine the code leading up to the error. Where was the divisor variable assigned its value? Was it calculated? Read from input? Returned from a function? Follow the data flow to find the origin of the zero.

Conclusion​

The ZeroDivisionError in Python occurs when attempting division (/, //) or modulo (%) with zero as the second operand.

To prevent or handle this error:

  1. Check Before Operating (Recommended): Use an if divisor != 0: statement to ensure the divisor/modulus is non-zero before performing the operation. Provide alternative logic or a default value in the else block.
  2. Use Exception Handling: Wrap the division/modulo operation in a try...except ZeroDivisionError: block to catch the error if it happens and handle it gracefully (e.g., assign a default value).

Always ensure your code anticipates the possibility of a zero divisor/modulus, especially when dealing with calculations, user input, or external data.

Table of Contents