A Comprehensive Guide to Exception Handling in Python

Exception handling is a mechanism in Python that deals with runtime errors, allowing the program to continue execution or handle errors gracefully. It is an essential tool for making Python applications robust and error-resistant.

Definition

An exception is an event that arises during a program’s execution, interrupting its regular flow. When an error occurs in a Python script, it triggers an exception, which can be managed to prevent the program from crashing (stopping).

Advantages of Exception Handling

1. Improved Code Readability: It allows errors to be handled cleanly.
2. Program Continuity: Exceptions enable programs to continue running even after encountering an error.
3. Error Logging: Helps diagnose the issue by capturing specific error details.
4. Separation of Error Handling Logic: Keeps normal code separate from error-handling logic.
5. Graceful Termination: Programs can terminate gracefully instead of crashing abruptly.

Two types of errors in a programming language

1. Syntax error
2. Runtime error

Syntax Error:

Syntax errors occurs when the code breaks or violates the rules or structure of the programming language. These errors are detected before the program runs, during the compilation or interpretation phase. The program cannot execute until the syntax error is fixed.

Example:

print("Hello World"  # Missing closing parenthesis

Explanation: In the above example, the closing parenthesis is missing, which results in a syntax error. The program will not run and will raise an error like:

SyntaxError: unexpected EOF while parsing

Note: A programmer must correct all syntax errors before executing the program.

Runtime Errors:

Runtime errors occurs during the execution of the program. These errors happen after the program has started executing and typically arise due to unexpected operations (e.g., division by zero, invalid operations on data types, programmer logic, memory problems, or end-user input… ).

Example:

x = 10 / 0  # Division by zero

Explanation: Here, the program will start executing but will break at the point where the division done by zero occurs. This will result in a runtime error like:

ZeroDivisionError: division by zero

Note: Exception Handling concept applicable for Runtime Errors but not for syntax errors.

Exception hierarchy diagram

Most commonly encounter error are

Types of Exceptions with Syntax:

1. try-except block:

try:
    # code that may raise an exception
except <ExceptionType>:
    # code to execute if the exception is raised

2. try with multiple except blocks:

try:
    # code that may raise an exception
except <ExceptionType>: # ZeroDivisionError
    # code to handle the exception
except <ExceptionType>: #ValueError
    # code to handle the exception
else:
    # code to execute if no exception was raised

3. Single except block can handle multiple exceptions:

try:
     # code that may raise an exception
except (Exception1,Exception2,exception3,..):
     # code that may raise an exception
                   # (OR)
except (Exception1,Exception2,exception3,..) as msg:
     # code that may raise an exception

Note: The following are different possible variations of except blocks.

1. except ZeroDivisionError:
2. except ZeroDivisionError as msg:
3. except (ZeroDivisionError, ValueError) :
4. except (ZeroDivisionError, ValueError) as msg:
5. except :

4. try-except-else block:

try:
    # code that may raise an exception
except <ExceptionType>:
    # code to handle the exception
else:
    # code to execute if no exception was raised

5. try-except-finally block:

try:
    # code that may raise an exception
except <ExceptionType>:
    # code to handle the exception
finally:
    # code that will always execute, regardless of exceptions

6. Raise exception:

raise <ExceptionType>('error message')

7. Custom Exceptions:

class CustomError(Exception):
    pass

Examples:

Basic try-except:

try:
    x = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero.")

try with multiple except blocks:

try:
      x=int(input("Enter First Number: "))
      y=int(input("Enter Second Number: "))
      print(x/y)
except ZeroDivisionError:
      print("Can't Divide with Zero")
except ValueError:
      print("please provide int value only")

Single except block can handle multiple exceptions:

try:
     x=int(input("Enter First Number: "))
     y=int(input("Enter Second Number: ")) 
     print(x/y)
except (ZeroDivisionError, ValueError) as z:
      print("Please Provide valid numbers only and problem is: ", z)

try-except-else-finally:

try:
    result = 10 / 5
except ZeroDivisionError:
    print("Division by zero!")
else:
    print("Result:", result)
finally:
    print("This block always executes.")

Raising a Custom Exception:

class InvalidAgeError(Exception):
    def __init__(self, age):
        self.age = age

def validate_age(age):
    if age < 18:
        raise InvalidAgeError("Age is less than 18.")

try:
    validate_age(15)
except InvalidAgeError as e:
    print(e)

Conclusion

Exception handling in Python ensures that errors are managed effectively without disrupting program execution. By handling errors using try-except blocks and creating custom exceptions, Python developers can write more robust, maintainable code.

Knowledge Check

Related Article No.4

Check out our Trending Courses Demo Playlist

Kick Start Your Career With Our Data Job

Social Media channels

► KSR Datavizon Website :- https://www.datavizon.com
► KSR Datavizon LinkedIn :- https://www.linkedin.com/company/datavizon/
► KSR Datavizon You tube :- https://www.youtube.com/c/KSRDatavizon
► KSR Datavizon Twitter :- https://twitter.com/ksrdatavizo