Python Tutorials

Python Exception Handling : Try Except

8 min read

Every programmer, no matter how experienced, writes code that encounters errors. A user might type the word “seven” when your application asked for the number 7. A network connection might drop right as you try to download a file. A script might try to open a database that has been renamed or deleted.

By default, when Python encounters a situation it doesn’t know how to handle, it panics. It throws a massive wall of red text (a “Traceback”) and completely crashes the program. For a user using your software, an abrupt crash is a terrible experience.

To build professional, bulletproof applications, we must anticipate these inevitable failures and tell Python exactly how to react to them without crashing. This safety net is called Exception Handling, and it is powered by the try, except, else, and finally keywords.

What is Handling Errors gracefully?

In Python, a syntax error means the code is written incorrectly and won’t run at all. An Exception, however, is a runtime error—it happens when the syntax is perfectly fine, but an impossible operation is attempted while the program is actively running (like dividing by zero).

Exception Handling is a structural code pattern used to intercept these runtime errors. Instead of halting the program, the code catches the exception and executes a designated fallback routine, allowing the program to gracefully recover and continue executing.

Syntax & Basic Usage

The absolute minimum requirement for error handling is a try block paired with an except block.

  • try: Python will attempt to run the code inside this block.
  • except: If any error happens inside the try block, Python immediately jumps here to execute the fallback code.
# A simple program to demonstrate basic error handling
print("Starting calculator...")

try:
    # Python attempts this dangerous calculation
    math_result = 10 / 0
    
    # If the line above crashes, Python skips the rest of the try block
    print(f"The result is {math_result}")

except:
    # This acts as the safety net
    print("Error: You cannot divide a number by zero!")

print("Calculator continues running normally...")

# Expected Output:
# Starting calculator...
# Error: You cannot divide a number by zero!
# Calculator continues running normally...

Code language: PHP (php)

Python Exception Handling Methods and Function Arguments

Using a generic except: block (called a “bare except”) is actually considered bad practice because it hides every type of error, making debugging impossible. Let’s explore the correct, professional ways to handle, inspect, and route different exceptions.

1. Catching Specific Exceptions

Python has dozens of built-in exceptions like ValueError, TypeError, FileNotFoundError, and KeyError. You should explicitly tell Python which exact error you are expecting to catch.

user_input = "forty-two"

try:
    # Trying to convert a word into an integer will cause a ValueError
    user_age = int(user_input)
    print(f"You are {user_age} years old.")

except ValueError:
    # This block ONLY runs if a ValueError specifically happens
    print("Invalid input! Please enter numbers only, not words.")

# Expected Output:
# Invalid input! Please enter numbers only, not words.

Code language: PHP (php)

2. Handling Multiple Different Exceptions

What if your code could fail in several different ways? You can stack multiple except blocks to handle different errors with different, specific solutions.

data_list = [10, 20, 30]
divisor_input = "0"

try:
    divisor = int(divisor_input)
    target_number = data_list[5] # This index doesn't exist!
    calculation = target_number / divisor

except ValueError:
    print("Error: The divisor must be a valid number.")
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
except IndexError:
    print("Error: Tried to access a list item that doesn't exist.")

# Expected Output:
# Error: Tried to access a list item that doesn't exist.

Code language: PHP (php)

3. Capturing the Error Message (as e)

Sometimes you want to show the user a friendly error message, but you still need to see the exact technical error Python generated for your server logs. You can capture the exception object using the as keyword.

try:
    # Trying to open a file that doesn't exist
    with open("missing_data.csv", "r") as data_file:
        content = data_file.read()

except FileNotFoundError as e:
    print("User Message: We couldn't find the requested file.")
    print(f"System Log: {e}") # Prints the actual internal error string

# Expected Output:
# User Message: We couldn't find the requested file.
# System Log: [Errno 2] No such file or directory: 'missing_data.csv'

Code language: PHP (php)

4. The else Block (Success Path)

The else block is placed after all except blocks. Code inside the else block will ONLY run if the try block succeeds without throwing any exceptions whatsoever.

student_score_input = "95"

try:
    score = int(student_score_input)

except ValueError:
    print("Error: Invalid score format.")

else:
    # This ONLY runs if the integer conversion above succeeded safely
    print(f"Database updated successfully. New score is {score}.")

# Expected Output:
# Database updated successfully. New score is 95.

Code language: PHP (php)

5. The finally Block (The Guarantee)

The finally block is placed at the very end of the chain. Code inside the finally block is absolutely guaranteed to run, regardless of whether the try block succeeded or crashed. This is traditionally used to clean up memory or close network connections.

database_connection_open = True

try:
    print("Connecting to database...")
    # Simulating a sudden database crash
    result = 100 / 0
    print("Saving data...")

except ZeroDivisionError:
    print("Transaction failed due to a math error.")

finally:
    # This executes no matter what happens above!
    database_connection_open = False
    print("Closing database connection safely to prevent memory leaks.")

# Expected Output:
# Connecting to database...
# Transaction failed due to a math error.
# Closing database connection safely to prevent memory leaks.

Code language: PHP (php)

6. Manually Triggering Exceptions (raise)

Sometimes, the Python syntax is fine, but the user is doing something that violates your business rules (like applying for a credit card while underage). You can manually trigger an error using the raise keyword.

def process_credit_application(applicant_age):
    if applicant_age < 18:
        # We manually trigger a ValueError with a custom message
        raise ValueError("Applicant must be at least 18 years old.")
    
    print("Application approved!")

# Running the function and catching our manually raised error
try:
    process_credit_application(16)
except ValueError as error_message:
    print(f"Application Denied: {error_message}")

# Expected Output:
# Application Denied: Applicant must be at least 18 years old.

Code language: PHP (php)

Real-World Practical Examples

Scenario 1: Robust User Input Validation

When building command-line tools or scraping form data, you can never trust the user. Using a while loop paired with a try-except block is the standard pattern for forcing users to provide valid data.

def get_valid_age():
    # Loop infinitely until the user gets it right
    while True:
        # In a real app, this would be input("Enter your age: ")
        simulated_user_input = "twenty" 
        
        try:
            validated_age = int(simulated_user_input)
            
            if validated_age < 0:
                raise ValueError("Age cannot be negative.")
                
        except ValueError as e:
            # We catch both the string-to-int crash AND our manual negative age crash
            print(f"Invalid input detected. Please try again.")
            
            # For this example, we break to avoid an infinite loop in the tutorial
            break 
            
        else:
            print("Age successfully verified!")
            return validated_age

get_valid_age()

# Expected Output:
# Invalid input detected. Please try again.

Code language: PHP (php)

Scenario 2: Safe API Network Requests

When fetching data from the internet, a dozen things can go wrong. The server might be down, the connection might time out, or the data might be formatted incorrectly.

# Simulating a network request dictionary containing API configuration
api_config = {
    "server_url": "[https://api.weather.com](https://api.weather.com)",
    "timeout_seconds": 30
}

def fetch_weather_data():
    try:
        print(f"Connecting to {api_config['server_url']}...")
        # Simulating a missing 'auth_token' key in the dictionary
        token = api_config["auth_token"] 
        print("Fetching data...")

    except KeyError as e:
        # Catches dictionary lookup failures
        print(f"Authentication Failed: Missing configuration key {e}")

    except Exception as e:
        # The ultimate fallback catch-all for any other unforeseen system errors
        print(f"An unexpected critical error occurred: {e}")

    else:
        print("Weather data retrieved successfully.")

    finally:
        print("Network request cycle completed.")

fetch_weather_data()

# Expected Output:
# Connecting to [https://api.weather.com](https://api.weather.com)...
# Authentication Failed: Missing configuration key 'auth_token'
# Network request cycle completed.

Code language: PHP (php)

Best Practices & Common Pitfalls

  • Never Use Bare except: blocks: Writing except: without specifying the error type is widely considered terrible practice. It intercepts everything, including KeyboardInterrupt (when a user tries to press Ctrl+C to forcefully stop a frozen program). Always use specific exceptions, or at the bare minimum, use except Exception as e:.
  • Keep try Blocks Tiny: Only put the specific line of code that might crash inside the try block. Do not wrap your entire 500-line script inside one massive try block. It makes finding the actual source of the error nearly impossible.
  • Don’t Use Exceptions for Control Flow: Exception handling is “expensive” for the computer to process. Do not use try-except as a substitute for standard if-else logic. For example, use if key in dictionary: instead of blindly trying to access the key and catching the KeyError.

Summary

  • Exceptions are runtime errors that normally crash your program.
  • The try block allows you to test a dangerous chunk of code.
  • The except block acts as a safety net, executing fallback code if an error occurs. You should explicitly name the errors you want to catch (e.g., except ValueError:).
  • The else block runs only if the try block succeeded perfectly without errors.
  • The finally block runs no matter what, ensuring resources are cleaned up whether the program crashed or succeeded.
  • Use the raise keyword to intentionally throw your own custom errors when business logic constraints are violated.

Leave a Comment