Python errors and exception handling

Errors and exceptions

A syntax error means Python cannot understand your code, so nothing runs. An exception is an error that happens *while* the program runs: the code is valid, but something goes wrong, such as dividing by zero or opening a missing file. Unhandled, an exception stops the program.

Common exceptions you will meet

try / except: catch the error, keep running

try:
    age = int(input("Age: "))
    print("Next year:", age + 1)
except ValueError:
    print("Please type a number")
print("Program continues")

If a line inside try raises a ValueError, Python jumps straight to the matching except block instead of crashing.

Always name the exception. A bare except: catches everything, including typing mistakes in your own code, and hides real bugs.

else and finally

try:
    f = open("marks.txt", encoding="utf-8")
except FileNotFoundError:
    print("File missing")
else:
    print(f.read())          # runs only if there was no exception
    f.close()
finally:
    print("Done")            # always runs, error or not

Catching several errors and reading the message

try:
    a = int(input("A: "))
    b = int(input("B: "))
    print(a / b)
except ValueError:
    print("Numbers only")
except ZeroDivisionError:
    print("B cannot be zero")

try:
    x = [1, 2, 3][9]
except (IndexError, KeyError) as e:
    print("Problem:", e)          # e holds the error message

raise: create your own error when data is wrong

def set_marks(marks):
    if not 0 <= marks <= 100:
        raise ValueError(f"marks must be 0-100, got {marks}")
    return marks

raise stops the function and sends the exception to whoever called it. Raise errors as soon as you spot bad data, instead of carrying on with wrong values.

Custom exceptions

For your own apps, make an exception class that inherits from Exception:

class InsufficientBalance(Exception):
    pass

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientBalance(f"balance is only Rs {balance}")
    return balance - amount

try:
    withdraw(500, 800)
except InsufficientBalance as e:
    print("Cannot withdraw:", e)

Keep asking until the input is valid

def read_int(prompt):
    while True:
        try:
            return int(input(prompt))
        except ValueError:
            print("That is not a whole number, try again")

marks = read_int("Marks: ")

This small function is worth keeping: almost every program that asks for numbers needs it.

Reading a traceback

When an exception is not caught, Python prints a traceback: the chain of calls that led to the error.

Traceback (most recent call last):
  File "bill.py", line 8, in <module>
    print(average([]))
  File "bill.py", line 2, in average
    return sum(nums) / len(nums)
ZeroDivisionError: division by zero

Read it from the bottom: the last line is the error, and the line above it is where it happened. Lines higher up show which call led there: here, average([]) was called with an empty list.

Common mistakes

• Using a bare except: that hides every bug.
• Putting too much code inside try, so you cannot tell which line failed.
• Catching an exception and doing nothing (pass), so errors disappear silently.
• Confusing SyntaxError (code cannot run) with exceptions (code fails while running).

Key points

• Put risky code in try and handle named exceptions in except.
• else runs on success; finally always runs.
• except SomeError as e gives you the message.
• raise signals bad data; custom exceptions inherit from Exception.

Practice questions

try:
    print(a / b)
except ZeroDivisionError:
    print("Cannot divide by zero")

try:
    print("A")
except ValueError:
    print("B")
else:
    print("C")
finally:
    print("D")

def check_age(age):
    if age < 0 or age > 120:
        raise ValueError("age must be 0-120")
    return age