How to Make Division by Zero to Zero in Python?

Rate this post
How to Make Division by Zero to Zero in Python?

In Python, division by zero generates the exception ZeroDivisionError:  division by zero.  This is because in mathematics, division by zero is undefined.

>>> 7 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Today we’ll go over some ways to avoid the zero division error in Python and force it to return a zero.

  • First, we’ll look into exception handling in Python.
  • Second, we’ll examine different ways to check for a zero denominator with an if statement. 
  • Third, we’ll learn about a conditional expression, also known as a Python ternary operator. 
  • Fourth, we’ll look at a solution using the Python logical operators and and or, and specifically taking advantage of their short-circuiting feature.

Method 1: Exception Handling

A common way to deal with errors or exceptions in programming is with exception handling

In Python, we use a try block that contains a return statement to divide 2 numbers.  If there is no division by zero error, then it will return the result. 

Otherwise, the except line will check if the specified exception name is a match, and then it will execute the code under the except block. In this case, we’re telling it to return 0. 

Let’s define a function as an example called  zero_div(x, y) which accepts two parameters – x for the numerator and y for the denominator.  

>>> def zero_div(x, y):
...   try:
...     return x / y
...   except ZeroDivisionError:
...     return 0
>>> zero_div(100, 25)
>>> zero_div(99, 0)
>>> zero_div(99, 9)
>>> zero_div(2021, 0)

As we can see, each time we call the function it will return the result of the division, or a zero if a ZeroDivisionError occurs.

Before we continue, I feel that I should mention this exception handling method falls into the common Python coding practice labeled EAFPeasier to ask for forgiveness than permission.  It is considered as a best practice, however, there’s no harm in seeing the other ways of solving this problem, right?  And if you’re wondering, there’s also a label for using if statements to make these checks to try to avoid the exception error – LBYLlook before you leap.  With that said, let’s move on.

If you love Python one-liners (like me), then here’s a way to code the division by zero exception handling.  We’ll make use of the Python built-in function exec().  We must pass in the try-except block as a string.  If there’s no division by zero, then we’ll print the result.  Otherwise, it will print zero. 

So how do we compose a string version of the try-except block?  

  print(x / y)
except ZeroDivisionError:

As long as you remember to insert the newline character "\n" after the first line, then you should be OK.

Below examples run the code a few times.  Note I used actual numerical values for the numerator and denominator instead of variables.

>>> exec('try: print(9/2) \nexcept ZeroDivisionError: print(0)')
>>> exec('try: print(9/0) \nexcept ZeroDivisionError: print(0)')
>>> exec('try: print(72/9) \nexcept ZeroDivisionError: print(0)')
>>> exec('try: print(72/0) \nexcept ZeroDivisionError: print(0)')

Read more about Python one line exception handling.

Method 2:  Check for a Zero Denominator

Let’s avoid the error altogether and just check if the denominator is a zero, shall we?  We can accomplish this with the following code that uses an if statement.  Let’s define a function again, zero_div(x, y).

>>> def zero_div(x, y):
...   if y: return x / y
...   else: return 0
>>> zero_div(100, 50)
>>> zero_div(100, 0)
>>> zero_div(525, 50)
>>> zero_div(525, 0)

As shown above, within the function we are first checking if the variable “y” is True.  In Python, the number 0 is evaluated to False, and all other numbers are evaluated as True.  A quick example using the built-in bool() function:

>>> bool(0)
>>> bool(500)
>>> bool(3)
>>> bool(-19)

As long as the variable “y” is not zero, then return the evaluation of x / y.  Otherwise, return 0.

An alternative to the above is to use the Python ternary operator.  Let’s re-code the function as follows:

>>> def zero_div(x, y):
...   return x / y if y else 0
>>> zero_div(88, 8)
>>> zero_div(88, 0)
>>> zero_div(8, 4)
>>> zero_div(42, 0)

As you can see, we’re still checking for a True value for the denominator, “y”.  If so, then it will return the evaluation of x / y.  If “y” is False, or zero, then 0 is returned.

Method 3:  Short-Circuit Operators

The last method we’ll go over makes use of the short-circuiting feature that is built into the and and or operators

For the and operator, if the first operand is evaluated as True, then the second operand is returned. But if the first operand is False, then it does not evaluate the second operand and returns False

For the or operator, if the first operand is True, then it doesn’t evaluate the second operand and returns the first operand.  If the first operand is False, then it returns the second operand.

Let’s rewrite our zero_div function one last time:

>>> def zero_div(x, y):
...   return y and x / y or 0
>>> zero_div(28, 7)
>>> zero_div(28, 0)

Let’s look at the logical expression step by step when passing 28 and 7 into the function.

We will rewrite “y and x / y or 0” as:

7 and 28/7 or 0

The 7 is evaluated as True.

True and 28/7 or 0

Applying the short-circuiting feature for the and expression, since the first operand is True, then the second operand is returned.  And we get the following:

28/7 or 0

Now let’s apply the short-circuiting feature for the or expression.  The first operand is not False, therefore it is returned without evaluating the second operand.  And we are left with 28/7, which is finally evaluated to 4.0.

Now let’s examine the next function call where x is 28 and y is 0.

0 and 28/0 or 0 – this will evaluate to:

False and 28/0 or 0

For the and short-circuit operation, since the first operand is False, then False is returned straightaway without evaluating the second operand and we’re left with:

False or 0

Finally, for the or short-circuit, since the first operand is False, then the second operand is returned which is 0.


Today we looked at three different methods to ignore the zero division error in Python and instead have it return a zero.  The first method is the preferred way which uses exception handling.  Second, we checked for a zero denominator by using Python’s ternary operator and also the standard if statement.  And lastly, we took advantage of the short-circuit operations that are built into the logical operators. 

Which method would you choose?  And what type of coder are you?  Do you agree that it’s easier to ask for forgiveness than permission, or are you more of a look before you leap hacker?  In any case, I would like to thank you for taking the time to explore this topic with me, and I’ll be seeing you in the next one!  Bye for now.