Python Exceptions: An Introduction

In Python, errors can be of two kinds, syntax errors, and exceptions. Errors are the issues or faults that arise in a program and cause the typical behavior of the program to become eccentric.

Errors are common, and even experienced developers can make these flaws. So, programmers can use the process of eradicating these bugs called debugging.

Without debugging, programmers cannot run their programs smoothly, which will stop the execution. So, this article will discuss what Python exceptions are and how to manage the program to work flawlessly without throwing any exceptional errors.

What are the different exception cases in Python?

An exception is a case where the execution of a program gets disrupted, and the normal execution of the program halts. In other words, when a Python script meets a condition it cannot manage, it throws an exception.

This exception comes under one of the types of errors in Python objects. In Python, when the Python interpreter finds errors, it returns different built-in exceptions during the execution of a program. Following are the different types of exceptions happening in Python:

AttributeError: Python throws this exception when it does not find an attribute or method on an object, such as when users try to access a non-existent element of the class instance.
ImportError: The Python interpreter throws this exception when an import statement cannot evaluate or load the specified module.
IndexError: The Python interpreter throws this exception when the index is out of range for a tuple, list, or any different type of sequence.
IOError: The Python interpreter throws this exception when an input and output operation, reading or writing a document, fails due to an I/O error.
KeyError: When the program does not find the key in the Python dictionary, the program returns an exceptional error.
NameError: The Python interpreter throws this exception when it does not find the variable or the function name in the current scope.
SyntaxError: The Python interpreter throws this exception when the Python interpreter undergoes a syntax error in the program, such as a case-sensitive error, misspelled keyword, a missing colon, tab errors, or an unbalanced parenthesis.
TypeError: The Python interpreter throws this exception when users apply an operation or function to an object of a wrong type, such as adding an integer to a string.
ValueError: The Python interpreter throws this exception when users call the function or method with an invalid argument or input. For instance, while trying to convert an integer to a string and the integer does not define a valid string, the program returns an exception.
ZeroDivisionError: When users try to divide a number by zero, it will generate an error.

There are several other exceptions in Python apart from these few exceptions. But users must remember that while working with Python programs, they must carefully handle such exceptions properly in their code using try-except blocks or other error-handling procedures.

These processes gracefully manage errors and prevent the program from halting its execution.

Difference between an error and exception in Python

Error	Exception
Users cannot handle errors as runtime.	Users can handle exceptions as runtime.
A Python program can throw an error at both compile time and runtime.	Though exceptions can occur at runtime, sometimes Python program throws checked exceptions at compile time.
An error can even halt the normal flow of the user's system and terminate a program.	But exceptions divert the normal flow of a program and alter the direction of the program execution.
Types of errors are: Syntax errors, Logical errors, and Runtime errors.	Types of exceptions are: checked exceptions and unchecked exceptions.
Users can never guess when errors occur until they find the cause behind any error.	Users can guess, handle and use the exception to alter the original flow of the program.

Examples to compare errors and exceptions in Python

Python interpreter throws an exception when the program has no syntax error, but it results in an error with some other logic.

Example 1:

a = 88
b = a / 0
print(b)

Output:

Explanation:

In the above code snippet, we divided a number, which returned a ZeroDivisionError, while it divided the number by zero.

Example 2:

a = 12
b = "This is an exceptional error"
c = a + b

Output:

Explanation:

In this code snippet, we used three variables where the program throws a TypeError: unsupported operand type(s) for +: 'int' and 'str.'"

Solution:

Users can use the try-catch black to resolve this exceptional error.

a = 12
b = "This is an exceptional error"
try:
	c = a + b
except TypeError:
	print("TypeError: This will throw an error since users cannot add an int and a str")

Output:

Explanation:

Users can use the try and except statements to catch and handle exceptions in programs. In the try block, users can keep the code that can throw exceptions and write those codes that manage the exception inside except block.

Example 3: Syntax Error exception in Python

Python interpreter returns a syntax error when it finds an invalid syntax while parsing the program.

For example, print(Hello Python) can throw a syntax error since we cannot directly pass string without double or single quotes.

There are several other invalid syntaxes, like misspelled keywords, improper indentation, inaccurate use of blocks, invalid declaration, etc.

Detecting and handling specific exception

While using the try statement, users can add more than one except block to specify handlers for different exceptions.

Syntax:

try:
    # Adding_statement(s)
except IndexError:
    # Adding_statement(s)
except ValueError:
    # Adding_statement(s)

Code Snippet:

def demo(a):
	if a < 10:
		b = a/(a-5)
	print("Value of b = ", b)
try:
	demo(5)
	demo(10)
except ZeroDivisionError:
	print("The program returns and handle ZeroDivisionError")
except NameError:
	print("The program returns and handle NameError")

Output:

Raising exception

The raise statement lets the users force a specific exception to take place. The only argument in raise indicates the exception the program will throw. It should be either an exception instance or an exception class.

Code Snippet:

try:
	raise NameError("This is an exception in Python") 
except NameError:
	print ("The exception")
	raise

Output:

Explanation:

The above code snippet will return a simple line printed as "The exception." But it will also throw a runtime error in the last due to the raise statement users used in the last line. The raise will determine whether the program throws an exception or not.

Conclusion

This article is about how exceptions occur in Python programs and how users can handle these exceptions. Also, exception handling can outweigh its disadvantages, like possible security risks, increased code complexities, or performance overhead, but users must handle exceptions with great care and attention.