Robust Error Handling with Python Try and Except

From small scripts to large applications, exceptional scenarios and errors are unavoidable in software. Without proper handling, these exceptions commonly lead to crashes, incorrect output, data corruption, security issues, and more. Studies of software defect root causes reveal up to 70% are connected to inadequate error and exception management.

Content Navigation show

Python provides powerful constructs for handling errors gracefully: try, except, else and finally. Combined they allow catching exceptions, dealing with them, recovering program state, and ensuring necessary cleanup. Altogether these tools enable writing extremely resilient code.

In this comprehensive guide, we will thoroughly cover Python exception handling, starting with foundations then diving into specialized techniques for use cases like validating user input, wrangling APIs, scraping websites, managing files and beyond.

The Critical Need for Exception Handling

Exceptions represent an interruption in normal program flow when an unexpected error or anomaly occurs. From user typing an invalid value, to connecting to an unresponsive remote server, to trying to read a missing file – exceptions are triggered across nearly all programs.

Common Exception Causes

Cause Example Exception
Invalid user input int("foo") ValueError
Mathematical error 1/0 ZeroDivisionError
Missing file open("missing.txt") FileNotFoundError
Network issue Dropped WiFi OSError

In Python and other languages, these exceptions create special objects containing details like an error message, exception type, stack trace and more.

Without handling, exceptions propagate up until terminating the program and outputting a scary traceback. This immediate halt ignores any in-flight computations and leaves data in an inconsistent state.

Poor Error Handling Outcomes

Risk Issue
Crashes Program halts, data corrupted
Incorrect output Results silently wrong
Data loss Partial writes not completed
Security flaws Info leaks from tracebacks

Studies by Cisco Systems found each hour of downtime from software crashes costs an average of $100,000 across industries like healthcare, banking and transportation.

Given the prevalence of exceptions and massive damage potential from poor handling, mastering techniques like try and except is mission critical for engineering robust Python systems.

Leveraging Try and Except Blocks

The try and except blocks form the core Python mechanism for handling raised exceptions.

The basic syntax follows:

try:
   # Attempt to execute code block
except:
   # Executes if an exception occurs

Any code inside the try block is executed first during normal program flow. Then if an exception occurs, control jumps immediately to the except block to handle it before resuming main flow.

We also have fine-grained control over which exceptions are managed:

try:
    user_input = int(input("Please enter a number: "))
except ValueError:
    print("That was not a valid number!")
except KeyboardInterrupt:
    print("Input interrupted")

Now ValueErrors from invalid inputs specifically trigger the handling logic, while KeyboardInterrupt is also prepared for.

Debugging Exceptions with the As Keyword

A key benefit of try/except is accessing valuable context around the exception through the as keyword: 

try:
   risky_call() 
except IOError as e:
   print("IOError occurred!", e)

Now the exception instance e gives info like error message, exception type, stack trace and more to help diagnose and manage issues.

Additional Blocks: Else & Finally

Beyond try and except, Python exposes additional blocks that expand handling capabilities…

Else executes only if the try block succeeds without exceptions: 

try:
   print("Try block executes")
except:
   print("Exception occurred!") 
else:
   print("Executes if no exceptions")

This allows code that should only run in the happy path.

Finally ensures execution after try/except blocks complete, even during program termination:

try:
   print("Try block executes first in any case")
finally: 
   print("Finally block executes afterward no matter what")

This enables critical cleanup tasks like releasing external resources.

Now equipped with a deeper understanding, let‘s explore specialized techniques and use case applications.

Validation User Input

A common source of exceptions comes from invalid user inputs. We can build validation with try/except…

while True:
   try:  
       user_age = int(input("Please enter your age: "))  
       break
   except ValueError:
       print("Sorry, invalid input - please enter a number")

print(f"User age is: {user_age}")

This loop continually prompts until given an integer, providing user-friendly errors.

Handling Requests Network Errors

APIs can fail for many reasons like bad URLs, connection issues or invalid responses. Try/except allows managing them: 

import requests

try:
    response = requests.get("https://api.example.com/status")   
    response.raise_for_status() # Raises HTTPError if bad response
except requests.ConnectionError:
    print("Failed to connect to server")
except requests.HTTPError as http_err:        
    print(f"HTTP error: {http_err}")  
else:
    print("Success!")

We can handle specifics like HTTP errors while having catch-all logic as fallback.

Accessing Files

Reading and writing files is prone to permission errors, missing files and more.

import json

try: 
    with open("data.json") as f:
        doc = json.load(f) 
except FileNotFoundError:        
    print("Couldn‘t locate data.json!")
except json.JSONDecodeError:
    print("Invalid JSON format")

Context managers via with statements nicely pair to ensure handles get released.

And Beyond!

Further use cases span:

  • Web Scraping: Catch invalid HTML, missing elements
  • Databases: Surface connection and query issues
  • Type Checking: Validate method arguments
  • 3rd Party Libraries: Handle imported module exceptions
  • Custom Validation: Throw errors early for complex rules

And the list continues!

Closing Thoughts on Handling Errors in Python

Robust error handling separates high quality software from buggy, amateur code. Mastering exceptions with try, except and friends provides the techniques to write resilient, production-grade Python systems ready for real-world scenarios.

Still have questions? The official Python documentation dives deeper, and I‘m happy to help explain further techniques! Please reach out anytime.

Tags: