A Complete Guide - Python Programming try, except, finally Blocks

Understanding try, except, and finally

In Python, the try, except, and finally statements are used in exception handling. Exception handling allows your program to continue running even when an error (or exception) occurs. Here's what each block does:

• try: Encloses the code that might raise an exception.
• except: Catches and handles the exception(s).
• finally: A block of code that runs after the try and except blocks, regardless of whether an exception was raised or not. It is often used for clean-up actions.

Let’s go through a few examples to understand how they work together.

Example 1: Basic try and except

In this example, we'll divide two numbers. We'll include exception handling to catch a ZeroDivisionError if the denominator is zero.

try:
    numerator = int(input("Enter the numerator: "))
    denominator = int(input("Enter the denominator: "))
    result = numerator / denominator
    print(f"The result is {result}")
except ZeroDivisionError:
    print("You cannot divide by zero!")

Steps Explained:

1. Input:

   • The program prompts the user to enter the numerator and the denominator.
   • These inputs are converted to integers and stored in the variables numerator and denominator.

2. Try Block:

   • The division operation (numerator / denominator) is placed inside the try block.
   • If an exception occurs during division (e.g., division by zero), the code execution moves to the except block.

3. Except Block:

   • The except block specifically catches the ZeroDivisionError.
   • If this error is raised, the program prints a message: "You cannot divide by zero!"

Running the Code

• Scenario 1 (No Error):

  • Inputs: numerator = 10, denominator = 2
  • Output: The result is 5.0

• Scenario 2 (Exception Occurs):

  • Inputs: numerator = 10, denominator = 0
  • Output: You cannot divide by zero!

Example 2: Catching Multiple Exceptions

Sometimes, you might want to handle different types of exceptions differently. We can modify the previous example to catch multiple types of exceptions.

try:
    numerator = int(input("Enter the numerator: "))
    denominator = int(input("Enter the denominator: "))
    result = numerator / denominator
    print(f"The result is {result}")
except ZeroDivisionError:
    print("You cannot divide by zero!")
except ValueError:
    print("Please enter valid integers!")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

Additional Points:

• ValueError:

  • Raised if the input values cannot be converted to integers.
  • In the example, if a non-integer value is entered, the program will print "Please enter valid integers!"

• General Exception Handling:

  • The last except block catches any exception that is not specifically handled by the other except blocks.
  • Exception is the base class for all exceptions.
  • as e: Assigns the caught exception to the variable e. This can then be printed or processed further.

Running the Code

• Scenario 3 (ValueError):

  • Inputs: numerator = 'ten', denominator = 2
  • Output: Please enter valid integers!

• Scenario 4 (Unexpected Error):

  • An unexpected error occurs, perhaps due to unforeseen conditions.
  • Output: An unexpected error occurred: <error description>

Example 3: Using finally

Let's add a finally block to our example. This block executes whether an exception is thrown or not, making it ideal for performing cleanup actions like closing files or releasing resources.

try:
    file = open('example.txt', 'r')
    content = file.read()
    print(content)
except FileNotFoundError:
    print("The file was not found!")
except IOError:
    print("An error occurred while reading the file!")
finally:
    file.close()
    print("File has been closed.")

Explanation:

• Opening a File:

  • The try block attempts to open a file named example.txt in read mode.
  • It reads the file's contents and prints them.

• Except Blocks:

  • The first except block catches FileNotFoundError, which is raised if the file does not exist.
  • The second except block catches IOError, which might occur if there is a problem accessing the file.

• Finally Block:

  • Regardless of whether an exception was raised or not, the finally block ensures that the file is closed using file.close().
  • It then prints "File has been closed."

Running the Code

• Scenario 5 (File Exists and Can Be Read):

  • Content of example.txt: "Hello, World!"
  • Output:

    Hello, World!
    File has been closed.
    

• Scenario 6 (File Does Not Exist):

  • Output:

    The file was not found!
    File has been closed.
    

• Scenario 7 (IOError Occurs):

  • Let’s assume there are permission issues to read example.txt.
  • Output:

    An error occurred while reading the file!
    File has been closed.
    

Example 4: Combining all Blocks with Raising an Exception

Let's write a more complex example where we not only catch existing exceptions but also raise our own custom exceptions using the raise statement.

def calculate_area(radius):
    if radius < 0:
        raise ValueError("Radius cannot be negative!")
    area = 3.14 * radius ** 2
    return area

try:
    radius = float(input("Enter the radius of the circle: "))
    area = calculate_area(radius)
    print(f"The area of the circle is {area}")
except ValueError as ve:
    print(f"ValueError: {ve}")
except TypeError as te:
    print(f"TypeError: {te}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")
finally:
    print("Calculation completed.")

Added Points:

• Custom Exception:

  • The calculate_area() function raises a ValueError if the radius is negative.

• Raising Exceptions:

  • Using the raise statement, you can manually throw exceptions under certain conditions.

• Combining Different Types of Errors:

  • This example demonstrates how to handle different types of errors, including custom exceptions.

Running the Code

• Scenario 8 (Valid Positive Radius):

  • Input: radius = 3
  • Output:

    The area of the circle is 28.26
    Calculation completed.
    

• Scenario 9 (Negative Radius):

  • Input: radius = -1
  • Output:

    ValueError: Radius cannot be negative!
    Calculation completed.
    

• Scenario 10 (Non-Numeric Input):

  • Input: radius = 'hello'
  • Output:

    ValueError: could not convert string to float: 'hello'
    Calculation completed.
    

Example 5: Using else with try, except, and finally

Python's try statement can also have an else block that executes if no exceptions were raised in the try block.

try:
    number = int(input("Enter a number: "))
    square_root = number ** 0.5
    print(f"The square root of {number} is {square_root}")
except ValueError:
    print("Please enter a valid integer.")
else:
    print("Operation successful!")
finally:
    print("Thank you for using the application.")

Explanation:

• Else Block:

  • The else block runs immediately after the try block if no exceptions were raised.
  • It is useful for executing code that should run only if the try block succeed.

• Finally Block:

  • The finally block still runs after both the try and else blocks, whether or not an exception occurred.

Running the Code

• Scenario 11 (No Exception):

  • Input: number = 9
  • Output:

    The square root of 9 is 3.0
    Operation successful!
    Thank you for using the application.
    

• Scenario 12 (Exception Occurs):

  • Input: number = 'abc'
  • Output:

    Please enter a valid integer.
    Thank you for using the application.
    

Summary

• try: Place potentially problematic code here.
• except: Handle specific exceptions based on their type.
• else: Run code if no exceptions were raised in the try block.
• finally: Use for cleanup actions; will always execute, regardless of exceptions.

By mastering these constructs, you'll create more robust and error-resistant Python programs. Happy coding!