Python - Exception Handling

Exception in Python:

An exception in Python is an event that occurs during the execution of a program and disrupts the normal flow of the program's instructions. When an exception occurs, the program stops its normal execution and jumps to a special code block known as an exception handler.

Here is an example program that demonstrates the concept of exceptions:

def divide_numbers(a, b):
    try:
        result = a / b
        print("Division result:", result)
    except ZeroDivisionError as e:
        print("Error:", e)
    except TypeError as e:
        print("Error:", e)
    except Exception as e:
        print("Generic Error:", e)
    else:
        print("No exception occurred.")
    finally:
        print("This block always executes.")

# Example usage
divide_numbers(10, 2)
divide_numbers(10, 0)
divide_numbers("10", 2)

Output:

Division result: 5.0
Error: division by zero
Generic Error: unsupported operand type(s) for /: 'str' and 'int'
This block always executes.

Difference between Syntax Errors and Exceptions:

Syntax Errors:

Syntax errors, also known as parsing errors, occur when there is a mistake in the structure of the code. These errors are detected by the Python interpreter during the parsing (compilation) phase before the program is executed. Syntax errors indicate that the code violates the language's grammar rules.

Here is an example of a syntax error:

# Syntax Error
print("Hello, World!"

Output:

  File "", line 2
    print("Hello, World!"
                          ^
SyntaxError: unexpected EOF while parsing

Exceptions:

Exceptions, on the other hand, occur during the execution of the program. These errors are not detected by the parser but are raised during runtime when a specific condition is encountered. Exceptions can be handled using try-except blocks.

Here is an example of an exception:

# Exception Example
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print("Error:", e)

Output:

Error: division by zero

In summary, syntax errors are detected during the parsing phase, while exceptions occur during the execution phase of a program.

Handling Exceptions in Python:

Exceptions in Python can be handled using the try, except, else, and finally blocks. The try block contains the code that might raise an exception, and the except block handles the exception.

Here is an example program:

try:
    # Code that might raise an exception
    num1 = int(input("Enter the numerator: "))
    num2 = int(input("Enter the denominator: "))
    
    result = num1 / num2

except ZeroDivisionError as e:
    # Handle division by zero exception
    print("Error:", e)

except ValueError as e:
    # Handle invalid input (non-integer) exception
    print("Error:", e)

else:
    # Execute if no exception occurs
    print("Result:", result)

finally:
    # Always execute, whether exception occurs or not
    print("Execution complete.")

Output:

Enter the numerator: 10
Enter the denominator: 2
Result: 5.0
Execution complete.

In this example, the program attempts to divide two numbers entered by the user. If the user enters a non-integer or attempts to divide by zero, the corresponding exceptions are caught and handled. The else block is executed if no exception occurs, and the finally block is always executed.

Purpose of try, except, else, and finally Blocks in Exception Handling:

The try, except, else, and finally blocks are used in Python for structured exception handling. They provide a way to handle exceptions gracefully and ensure that certain code is executed regardless of whether an exception occurs or not.

• try: This block contains the code that might raise an exception. It is the part of the code that needs to be monitored for potential errors.
• except: If an exception occurs in the try block, the corresponding except block is executed. It handles and catches the exception, preventing the program from crashing.
• else: This block is executed if no exceptions occur in the try block. It contains code that should run only when there are no exceptions.
• finally: This block always gets executed, whether an exception occurs or not. It is useful for releasing resources or cleaning up, ensuring that certain actions are taken regardless of the outcome.

Here is an example program illustrating the use of these blocks:

try:
    num1 = int(input("Enter the numerator: "))
    num2 = int(input("Enter the denominator: "))
    
    result = num1 / num2

except ZeroDivisionError as e:
    print("Error:", e)

except ValueError as e:
    print("Error:", e)

else:
    print("Result:", result)

finally:
    print("Execution complete.")

Output (Example):

Enter the numerator: 10
Enter the denominator: 2
Result: 5.0
Execution complete.

In this example, the program attempts to divide two numbers entered by the user. The try, except, else, and finally blocks work together to handle exceptions and ensure that the program completes its execution.