Python Try Except: Examples And Best Practices

The last line of a traceback tells you which exception happened (ValueError), and that’s the name you put after except. If error messages like this still feel intimidating, the free lesson Errors Are Part of Programming in my Python Fundamentals course lets you cause one on purpose and fix it, right in your browser.

Try catch in Python? It’s called try except

If you come from Java, JavaScript, C# or PHP, you’re probably looking for try ... catch. Python has no catch keyword. It uses except instead, and it works the same way. Here’s how the keywords map:

So a Java-style try catch looks like this in Python:

try:
    print(2/0)
except ZeroDivisionError as e:
    print("Caught:", e)
finally:
    print("This always runs")Code language: Python (python)

Caught: division by zero
This always runs

A few other differences are worth knowing. Python has no checked exceptions, so you never declare which exceptions a function throws. Raising an exception is called raising, not throwing (though people use both words). And exceptions are cheap enough in Python that using them for normal control flow is common and accepted. More on that in It’s better to ask for forgiveness.

What is an exception?

An exception is a condition that arises during a program’s execution. It is a signal that something unexpected happened. Python represents exceptions by an object of a specific type.

In Python, all built-in, non-system-exiting exceptions are derived from the Exception class. Exceptions have their own descriptive names. For example, if you try to divide a number by zero, you will get a ZeroDivisionError exception, which is also a subclass of the Exception class.

For a complete hierarchy of all exceptions, you can view the Python manual if you’re interested. Here’s a small excerpt from this hierarchy to illustrate:

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- BaseExceptionGroup
 +-- Exception
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- OSError
      |    +-- FileNotFoundError
      |    +-- PermissionError
      .....

This hierarchy matters when you catch exceptions: except ArithmeticError also catches a ZeroDivisionError, and except OSError also catches a FileNotFoundError. If your knowledge about objects, classes, and inheritance is a bit rusty, you may want to read my article on objects and classes and my article on inheritance first.

Python try except

When something unexpected occurs, we can raise an exception at the point of the error. When an exception is raised, Python stops the current flow of execution and starts looking for an exception handler that can handle it. So what is an exception handler? Here’s where the try and except statements come into play.

As the illustration shows, we start a code block with a try statement. This means: try to run this code, but an exception might occur.

After our try block, one or more except blocks follow (or a finally block, more on that later). These except blocks can catch an exception, as we usually call this. Each except block can handle a specific type of exception.

Remember: classes are hierarchical. For that reason, exceptions are hierarchical as well. Python checks the except blocks from top to bottom and runs the first one that matches, so they must go from the most specific, like a ZeroDivisionError, to less specific, like an ArithmeticError. Get the order wrong and the specific block never runs:

try:
    print(2/0)
except ArithmeticError:
    print("Some arithmetic went wrong")
except ZeroDivisionError:
    print("You can't divide by zero!")Code language: Python (python)

Some arithmetic went wrong

The same thing happens, on a larger scale, if you start with an except block that catches Exception. That first block catches almost everything, so the other except blocks are useless.

When an exception is raised, the handler that catches it can be nearby, but it can also be in a different function or even a different module. Python doesn’t scan your code randomly for an exception handler. Instead, the handler should be somewhere in the call stack.

Call stack

A call stack is an ordered list of functions that are currently being executed. For example, you might call function A, which calls function B, which calls function C. We now have a call stack consisting of A, B, and C. When C raises an exception, Python will look for an exception handler in this call stack, going backward from end to start. It can be in function C (closest to the exception), in function B (somewhat farther), in function A, or even at the top level of the program where we called function A.

If Python finds a suitable except block, it executes the code in that block. If it doesn’t find one, Python handles the exception by itself. This means it will print the exception and exit the program since it has no clue what to do with it.

If this feels abstract, don’t worry. The examples below will make it concrete, and you might want to come back to this section after finishing the article.

Catching exceptions with try except

To handle an exception, we need to catch it. As we just learned, we catch an exception with the try and except keywords. When an exception occurs while we are inside the try block, the code in the matching except block is executed.

A simple try except example

Let’s try a simple example first. As you hopefully know, we can’t divide by the number zero. If we do so anyway, Python raises an exception called ZeroDivisionError, which is a subclass of ArithmeticError:

try:
    print(2/0)
except ZeroDivisionError:
    print("You can't divide by zero!")Code language: Python (python)

You can't divide by zero!

If you call a Python function inside the try block, and an exception occurs in that function, the flow of code execution stops at the point of the exception and the code in the except block is executed. Try doing this again without try and except, and you’ll see that Python prints the exception for us:

print(2/0)Code language: Python (python)

Output:

Traceback (most recent call last):
  File "divide_by_zero.py", line 1, in <module>
    print(2/0)
          ~^~
ZeroDivisionError: division by zero

Also, note that Python prints the error to stderr if you don’t handle the exception yourself.

Python try except with a specific exception

Always name the exception you expect after except. That way you handle the one problem you planned for, and anything else still shows up as a normal error. Here we read an optional setting from a dictionary and fall back to a default when the key is missing:

config = {"host": "localhost"}

try:
    port = config["port"]
except KeyError:
    port = 8080

print(f"Connecting to port {port}")Code language: Python (python)

Connecting to port 8080

Only a KeyError is caught. If you made a typo and wrote confg["port"], you’d get a NameError with a clear traceback, which is exactly what you want while developing. (For this particular case, config.get("port", 8080) from the dictionaries article is shorter, but the pattern is the same for any operation that can fail.)

Catching IOError (OSError and FileNotFoundError)

Let’s try another, more common example. After all, who divides a number by zero, right?

Exceptions are likely to occur when interacting with the outside world, e.g., when working with files or networks. For example, if you try to open a file with Python, but that file doesn’t exist, you get a FileNotFoundError. If you don’t have access to a file due to permissions, you get a PermissionError. Both are subclasses of OSError.

You’ll still see IOError in older tutorials. Since Python 3.3 it’s just another name for OSError, so except IOError still works, but OSError (or the more specific subclasses) is what you should write today.

Assignment

Please do the following:

1. Run the code below on your computer, and notice the file name (it doesn’t exist). See what happens.
2. Create a file called myfile.txt in the same folder, change the file name in the code to myfile.txt, and rerun the code. What happens now?

Here’s the code to copy/paste:

try:
    # Open file in read-only mode
    with open("not_here.txt", 'r') as f:
        f.write("Hello World!")
except OSError as e:
    print("An error occurred:", e)Code language: Python (python)

Answers

The file is not found in the first case. You should get this output:

An error occurred: [Errno 2] No such file or directory: 'not_here.txt'

You’ll still get an error after creating the file in the second case. This time, we’re trying to write to a file that is opened in read-only mode. For more information on these modes, read the article on opening, reading, and writing files with Python. The error should look like this:

An error occurred: not writable

Although this is an error, it’s not written to the stderr output of the operating system. That’s because we handled the exception ourselves. If you remove the try and except from the code and then try to write to the file in read-only mode, the exception reaches the top of the program, Python stops the program, and shows this message:

def parse_age(value):
    try:
        return int(value)
    except (ValueError, TypeError):
        return None

print(parse_age("39"))
print(parse_age("thirty-nine"))
print(parse_age(None))Code language: Python (python)

39
None
None

def read_number(path):
    try:
        with open(path) as f:
            return int(f.read())
    except FileNotFoundError:
        print(f"{path} doesn't exist")
    except ValueError:
        print(f"{path} doesn't contain a number")

read_number("missing.txt")Code language: Python (python)

missing.txt doesn't exist

try:
    with open("settings.toml") as f:
        settings = f.read()
except FileNotFoundError as e:
    print("Message:  ", e)
    print("Type:     ", type(e).__name__)
    print("Filename: ", e.filename)
    print("Args:     ", e.args)Code language: Python (python)

Message:   [Errno 2] No such file or directory: 'settings.toml'
Type:      FileNotFoundError
Filename:  settings.toml
Args:      (2, 'No such file or directory')

try:
    1 / 0
except ZeroDivisionError as e:
    pass

print(e)Code language: Python (python)

try:
    ...
except Exception as e:
    print("There was an error:", e)Code language: Python (python)

import traceback

try:
    1 / 0
except ZeroDivisionError:
    traceback.print_exc()

print("The program keeps running")Code language: Python (python)

def show_number(text):
    try:
        number = int(text)
    except ValueError:
        print(f"{text!r} is not a number")
    else:
        print(f"{number} squared is {number ** 2}")
    finally:
        print("Done with", repr(text))

show_number("12")
show_number("twelve")Code language: Python (python)

12 squared is 144
Done with '12'
'twelve' is not a number
Done with 'twelve'

def read_file(path):
    f = open(path)
    try:
        return f.read()
    finally:
        print("Closing the file now")
        f.close()

with open("myfile.txt", "w") as f:
    f.write("Hello World!")

print(read_file("myfile.txt"))Code language: Python (python)

Closing the file now
Hello World!

def set_age(age):
    if age < 0:
        raise ValueError(f"age can't be negative, got {age}")
    print(f"Age set to {age}")

set_age(39)
set_age(-1)Code language: Python (python)

def load(path):
    try:
        with open(path) as f:
            return f.read()
    except FileNotFoundError:
        print(f"Logging: {path} is missing")
        raise

load("config.toml")Code language: Python (python)

class ConfigError(Exception):
    pass

def read_port(settings):
    try:
        return int(settings["port"])
    except (KeyError, ValueError) as e:
        raise ConfigError("port must be set to a number") from e

read_port({"port": "eighty"})Code language: Python (python)

rows = ["1", "2", "three"]

for line_number, row in enumerate(rows, start=1):
    try:
        value = int(row)
    except ValueError as e:
        e.add_note(f"while reading line {line_number} of data.csv")
        raiseCode language: Python (python)

class UserNotFoundError(Exception):
    passCode language: Python (python)

class UserNotFoundError(Exception):
    pass

def fetch_user(user_id):
    # Here you would fetch from some kind of db, e.g.:
    # user = db.get_user(user_id)

    # To make this example runnable, let's set it to None
    user = None

    if user is None:
        raise UserNotFoundError(f"User {user_id} not in database")
    return user

users = [123, 456, 789]
for user_id in users:
    try:
        fetch_user(user_id)
    except UserNotFoundError as e:
        print("There was an error:", e)Code language: Python (python)

There was an error: User 123 not in database
There was an error: User 456 not in database
There was an error: User 789 not in database

class ShopError(Exception):
    """Base class for all errors in our shop code."""

class OutOfStockError(ShopError):
    def __init__(self, product, requested, available):
        super().__init__(f"{product}: asked for {requested}, only {available} left")
        self.product = product
        self.available = available

class PaymentDeclinedError(ShopError):
    pass

try:
    raise OutOfStockError("coffee mug", 3, 1)
except OutOfStockError as e:
    print(e)
    print(f"We can still sell you {e.available}")
except ShopError as e:
    print("Something else went wrong in the shop:", e)Code language: Python (python)

coffee mug: asked for 3, only 1 left
We can still sell you 1

def validate(user):
    errors = []
    if not user.get("name"):
        errors.append(ValueError("name is required"))
    if not isinstance(user.get("age"), int):
        errors.append(TypeError("age must be a whole number"))
    if "email" not in user:
        errors.append(KeyError("email"))
    if errors:
        raise ExceptionGroup("invalid user", errors)

try:
    validate({"name": "", "age": "39"})
except* ValueError as eg:
    for e in eg.exceptions:
        print("Value problem:", e)
except* TypeError as eg:
    for e in eg.exceptions:
        print("Type problem:", e)
except* KeyError as eg:
    for e in eg.exceptions:
        print("Missing field:", e)Code language: Python (python)

Value problem: name is required
Type problem: age must be a whole number
Missing field: 'email'

try:
    raise ExceptionGroup("two problems", [ValueError("bad value"), OSError("disk full")])
except* ValueError as eg:
    print("Handled:", eg.exceptions)Code language: Python (python)

import asyncio

async def fetch(name, fail):
    await asyncio.sleep(0.1)
    if fail:
        raise ConnectionError(f"{name} is down")
    return f"{name} ok"

async def main():
    try:
        async with asyncio.TaskGroup() as tg:
            tg.create_task(fetch("api", fail=True))
            tg.create_task(fetch("db", fail=True))
            tg.create_task(fetch("cache", fail=False))
    except* ConnectionError as eg:
        for e in eg.exceptions:
            print("Failed:", e)

asyncio.run(main())Code language: Python (python)

Failed: api is down
Failed: db is down

prices = {"apple": 0.5, "pear": 0.75}

def price_of(item):
    try:
        price = prices[item]
    except KeyError:
        return None
    return round(price * 1.21, 2)

print(price_of("apple"))
print(price_of("kiwi"))Code language: Python (python)

0.6
None

try:
    do_something()
except Exception:
    passCode language: Python (python)

import logging

logging.basicConfig(format="%(levelname)s: %(message)s")

def load_avatar(path):
    try:
        with open(path, "rb") as f:
            return f.read()
    except FileNotFoundError:
        logging.warning("No avatar at %s, using the default", path)
        return b""

load_avatar("avatars/erik.png")Code language: Python (python)

WARNING: No avatar at avatars/erik.png, using the default

import os
from contextlib import suppress

with suppress(FileNotFoundError):
    os.remove("old_cache.tmp")

print("Cache cleared (or there was nothing to clear)")Code language: Python (python)

Cache cleared (or there was nothing to clear)

try:
    ...
except:
    print("An error occurred")Code language: Python (python)

from time import sleep

while True:
    try:
        print("Try and stop me")
        sleep(1)
    except:
        print("Don't stop me now, I'm having such a good time!")

from time import sleep

while True:
    try:
        print("Try and stop me")
        sleep(1)
    except Exception:
        print("Something went wrong")

import json

user_json = '{"name": "John", "age": 39}'
user = json.loads(user_json)

try:
    print(user['name'])
    print(user['age'])
    print(user['address'])
except KeyError as e:
    print("There are missing fields in the user object:", e)Code language: Python (python)

John
39
There are missing fields in the user object: 'address'