Exceptions Basics

Errors happen - files go missing, users enter invalid data, networks fail. Python's exception system lets you handle these gracefully instead of crashing. Understanding the difference between syntax errors and runtime exceptions, knowing the common exception types, and being able to read tracebacks are essential skills for every Python developer!

Syntax Errors vs Exceptions

Syntax errors occur when Python can't parse your code - it doesn't understand what you wrote. These must be fixed before the program can run. Exceptions occur during execution when something goes wrong at runtime. The code is valid Python, but the operation failed (like dividing by zero).

Click Run to execute your code

Common Exception Types

Python has dozens of built-in exception types, each for specific error conditions. Knowing the common ones helps you write better error handling and debug faster. The most frequent exceptions you'll encounter are TypeError, ValueError, KeyError, IndexError, and FileNotFoundError.

Click Run to execute your code

Exception Hierarchy

Python exceptions form a class hierarchy. All exceptions inherit from BaseException, and most inherit from Exception. Understanding the hierarchy helps you catch related exceptions together - catching LookupError catches both IndexError and KeyError.

Click Run to execute your code

Reading Tracebacks

When an exception occurs, Python prints a traceback - a record of where the error happened and how the code got there. Read tracebacks from bottom to top: the error type is at the bottom, and the call stack shows how you got there.

Click Run to execute your code

Common Mistakes

# Wrong - catches everything, hides bugs!
try:
    result = do_something()
except:  # Bare except - NEVER do this!
    pass

# Also wrong - too broad
except Exception:
    pass  # Silently ignoring all errors

# Correct - catch specific exceptions
try:
    result = do_something()
except ValueError:
    print("Invalid value provided")
except FileNotFoundError:
    print("File not found")

# Wrong - throwing away useful info!
try:
    data = json.loads(user_input)
except json.JSONDecodeError:
    print("Invalid JSON")  # What was wrong?

# Correct - use the error message
try:
    data = json.loads(user_input)
except json.JSONDecodeError as e:
    print(f"Invalid JSON at position {e.pos}: {e.msg}")

# Wrong - specific exception never reached!
try:
    open("file.txt")
except OSError:
    print("OS error")  # Catches FileNotFoundError too!
except FileNotFoundError:
    print("File not found")  # Never runs!

# Correct - specific exceptions first
try:
    open("file.txt")
except FileNotFoundError:
    print("File not found")  # Runs for missing files
except OSError:
    print("Other OS error")  # Catches remaining OS errors

# Wrong - using exceptions as if/else
try:
    value = my_dict[key]
except KeyError:
    value = default

# Correct - use dict.get() or 'in' check
value = my_dict.get(key, default)

# Or
if key in my_dict:
    value = my_dict[key]
else:
    value = default

# Error: AttributeError: 'NoneType' has no attribute 'strip'
# Many developers just see "AttributeError" and get confused

# The key info is 'NoneType' - something returned None!
# Check what could be None:

result = get_user_input()  # This returned None!
cleaned = result.strip()   # Can't call .strip() on None

# Fix: Check for None
result = get_user_input()
if result is not None:
    cleaned = result.strip()

Exercise: Exception Identifier

Click Run to execute your code

def identify_exception(func):
    """Run a function and return the exception type name."""
    try:
        func()
        return "No exception"
    except Exception as e:
        return type(e).__name__


# Test cases
test_cases = [
    ("Division by zero", lambda: 1 / 0),
    ("String + int", lambda: "a" + 1),
    ("List index", lambda: [1, 2, 3][10]),
    ("Dict key", lambda: {}["missing"]),
    ("Int parse", lambda: int("hello")),
    ("File open", lambda: open("nonexistent.txt")),
    ("No error", lambda: 1 + 1),
]

print("=== Exception Identifier ===\n")
for name, func in test_cases:
    result = identify_exception(func)
    print(f"{name:20} -> {result}")

# Expected output:
# Division by zero     -> ZeroDivisionError
# String + int         -> TypeError
# List index           -> IndexError
# Dict key             -> KeyError
# Int parse            -> ValueError
# File open            -> FileNotFoundError
# No error             -> No exception

Summary

What's Next?

Now that you understand what exceptions are, let's learn how to handle them with try/except. You'll learn to catch exceptions gracefully, handle multiple exception types, and keep your programs running even when errors occur!