Errors.
Read them. Catch them. Raise them.

Traceback (most recent call last):
 File "app.py", line 15, in 
 main()
 File "app.py", line 8, in main
 process(data)
 File "app.py", line 3, in process
 return items[10]
IndexError: list index out of range

# Basic try/except
try:
n = int(input("Enter a number: "))
print(f"Double: {n * 2}")
except ValueError:
print("That wasn't a number.")

# Catch multiple specific types
try:
data = {"name": "Alice"}
print(data["age"])
except (KeyError, IndexError) as e:
print(f"Missing: {e}")

# Multiple separate except blocks
try:
result = 10 / 0
except ZeroDivisionError:
print("Can't divide by zero")
except TypeError:
print("Wrong type")

# Access the exception object with "as e"
try:
open("missing.txt")
except FileNotFoundError as e:
print(f"Error: {e}") # [Errno 2] No such file or directory: 'missing.txt'

# Return defaults on failure (very common pattern)
def safe_int(text):
try:
return int(text)
except ValueError:
return 0

# Raise a built-in exception
def validate_age(age):
if age < 0:
raise ValueError(f"Age can't be negative: {age}")
return age

validate_age(-5)
# ValueError: Age can't be negative: -5

# The caller handles it
try:
validate_age(-5)
except ValueError as e:
print(f"Invalid input: {e}")

# Bare raise — re-raise the current exception
def load_config(path):
try:
with open(path) as f:
return f.read()
except FileNotFoundError:
print(f"Config missing: {path}")
raise # re-raises the original, preserving traceback

# Raise from — chain exceptions for context
try:
int("not a number")
except ValueError as e:
raise RuntimeError("Config parsing failed") from e
# Traceback shows BOTH: RuntimeError caused by ValueError

# else — runs only if try succeeded
try:
value = int("42")
except ValueError:
print("Bad input")
else:
print(f"Success: {value}") # runs only on success

# finally — runs no matter what
def process_file(path):
f = open(path)
try:
return f.read()
finally:
f.close() # ALWAYS runs, even if read() raised

# All four clauses together (rare but legal)
try:
result = risky_operation()
except ValueError as e:
print(f"Error: {e}")
except TypeError:
print("Wrong type")
else:
print(f"Got: {result}")
finally:
print("Cleanup done")

# finally runs even if try returns
def demo():
try:
return "from try"
finally:
print("finally runs") # ALWAYS

print(demo())
# finally runs
# from try

# Define a custom exception
class ValidationError(Exception):
"""Raised when user input fails validation."""
pass

# Use it
def validate_email(email):
if "@" not in email:
raise ValidationError(f"Invalid email: {email}")
return email

# Caller can catch it specifically
try:
validate_email("not-an-email")
except ValidationError as e:
print(f"Please fix: {e}")

# Custom exception with extra data
class APIError(Exception):
def init(self, message, status_code):
super().init(message)
self.status_code = status_code

try:
raise APIError("Not found", status_code=404)
except APIError as e:
print(f"Status {e.status_code}: {e}")

# Exception hierarchy — catch a group
class AppError(Exception):
"""Base class for all app errors."""
pass

class DatabaseError(AppError):
pass

class NetworkError(AppError):
pass

# Catch all app errors with one except
try:
connect_database()
except AppError as e:
print(f"App failed: {e}") # catches DatabaseError, NetworkError, etc.

# user_import.py — import users from a file with proper error handling
import json

class ValidationError(Exception):
"""Raised when a user record fails validation."""
pass

def validate_user(user):
"""Check required fields. Raise ValidationError with a useful message."""
if "name" not in user or not user["name"]:
raise ValidationError("Missing required field: name")
if "age" in user and (not isinstance(user["age"], int) or user["age"] < 0):
raise ValidationError(f"Invalid age: {user.get('age')}")
return user

def import_users(path):
"""Load users from a JSON file. Return list of valid users and a list of errors."""
try:
with open(path, encoding="utf-8") as f:
raw = json.load(f)
except FileNotFoundError:
raise ValidationError(f"File not found: {path}")
except json.JSONDecodeError as e:
raise ValidationError(f"Invalid JSON in {path}: {e}")

valid = []
errors = []

for i, user in enumerate(raw):
try:
validate_user(user)
valid.append(user)
except ValidationError as e:
errors.append(f"Row {i}: {e}")

return valid, errors

# Use it
try:
users, errors = import_users("users.json")
print(f"Imported {len(users)} users")
for err in errors:
print(f" {err}")
except ValidationError as e:
print(f"Import failed: {e}")
finally:
print("Done.")

# Output (assuming users.json exists with 3 rows, 1 invalid):
# Imported 2 users
# Row 1: Invalid age: -5
# Done.