When programming, encountering errors or mistakes is very common, but fixing them can be a complex task. A good programmer is characterized by their ability to easily identify and debug any errors.
Errors can generally be divided into three categories:
- Compile Time Errors/Syntax Errors
- Run Time Errors
- Logical Errors
Compile Time Errors/Syntax Errors
Among all types of errors, handling compiler errors or syntax errors is the easiest because they are caught at compile time, and in most cases, the compiler itself indicates where the mistake is. For example, if we forget to put a colon while defining a function or class, it will be a compile time error. For instance:
#This program is an example of compiler/syntax error in Python
print("This is an error"
Output:
print("This is an error"
^
SyntaxError: '(' was never closedHere, it shows an error, which is a SyntaxError.
Run Time Errors
A program might encounter run time errors based on input or results after it starts running. These types of errors are a bit more challenging to identify compared to syntax errors. Let’s look at an example:
#This program is an example of run time error in Python
a=15
b=5
c=0
print(a/b)
print(a/c) # Divide by zero error
Output:
3.0
Traceback (most recent call last):
File "main.py", line 8, in <module>
print(a/c)
ZeroDivisionError: division by zeroHere, the result is 3.0 from line 7, but an error occurs on line 8 due to a divide by zero issue. This means the program ran correctly, but an error occurred because of a value problem.
Logical Errors
Any human-made mistake that primarily occurs due to the programmer is a logical error. Let’s say we want to display numbers from 1 to 10 using a loop:
i=1
while(i<10):
print(i)
i+=1
Result:
1
2
3
4
5
6
7
8
9The result shows numbers from 1 to 9, not 10, because there is a logical error. The mistake occurred because of using the condition < in the while loop. This can be fixed in two ways: either by using <= or by changing the condition to 11 instead of 10. Let’s look at these two solutions:
i=1
while(i<=10):
print(i)
i+=1
Or
i=1
while(i<11):
print(i)
i+=1
Exception Handling
So far, we have seen different types of errors. Now, let’s see how to manage these errors. During run time errors, we saw that the whole program stops running if an error is caught; however, ideally, only the problematic part should be skipped. Python has specific methods for handling these errors:
Try and Except
The try statement handles errors in a code block and directs them to the except block. Let’s revisit the previous example within a try block:
#This program is an example of try except block in Python
a=15
b=5
c=0
try:
print(a/b)
print(a/c) # Divide by zero error
except Exception as e:
print("This is an Exception",e)
Output:
3.0
This is an Exception division by zero
Here, the try block caught an error and sent it to the except block. Previously, the entire program stopped running; now, it worked as much as possible and then displayed our defined message. Thus, the program was able to continue running normally without any major issues.
Finally
Besides try and except, there is also a finally statement, which executes regardless of whether there is an error or not. Let’s revisit the previous example:
a=15
b=5
c=0
try:
print(a/b)
print(a/c) # Divide by zero error
except Exception as e:
print("This is an Exception",e)
finally:
print("This is from the final block")
Output:
3.0
This is an Exception division by zero
This is from the final block We can see that after displaying the exception from the except block, it also displayed the message from the finally block. Now, let’s see an example without any errors:
a=15
b=5
try:
print(a/b)
except Exception as e:
print("This is an Exception",e)
finally:
print("This is from the final block")
Output:
3.0
This is from the final blockIn other words, the finally block executes whether there is an error or not.