What Is try in Python? Absolute Beginners Tutorial

Every program will eventually encounter bad input, missing files, or network failures. The try statement is how Python lets you handle those situations without the program crashing. This tutorial explains what try is, how it works, and how to combine it with except, else, and finally.

When Python runs a program and something goes wrong — dividing by zero, opening a file that does not exist, converting a string that is not a number — it raises an exception. Without any error handling, the program stops immediately and prints a traceback. The try statement gives you control over what happens instead.

What Is the try Statement?

The try statement marks a block of code that Python should attempt to run. If an error occurs anywhere inside that block, Python immediately stops executing it and looks for a matching except clause to handle the error. If no error occurs, the except block is skipped entirely.

Here is the simplest possible structure:

try:
    result = 10 / 0          # this line raises ZeroDivisionError
    print(result)
except ZeroDivisionError:
    print("You cannot divide by zero.")

When Python reaches 10 / 0 it raises a ZeroDivisionError. Because that line is inside a try block, Python does not crash. Instead it jumps straight to the except ZeroDivisionError: clause and prints the message.

Without the try statement the same code would produce this traceback and halt the program:

Traceback (most recent call last):
  File "example.py", line 1, in <module>
    result = 10 / 0
ZeroDivisionError: division by zero

except, else, and finally

A try block can be followed by up to three additional clauses. Each one serves a distinct purpose, and knowing when to use each one is the heart of writing clean error-handling code.

"Errors should never pass silently. Unless explicitly silenced." — Tim Peters, The Zen of Python (PEP 20)

Here is a full example showing all four clauses together:

def parse_integer(text):
    """Convert a string to int, returning None if conversion fails."""
    try:
        value = int(text)
    except ValueError:
        print(f"Could not convert {text!r} to an integer.")
        return None
    else:
        print(f"Converted successfully: {value}")
        return value
    finally:
        print("parse_integer() finished.")

parse_integer("42")     # succeeds — else and finally both run
parse_integer("hello")  # fails  — except and finally both run

Catching Multiple Exception Types

A single try block can have as many except clauses as you need. Python checks them from top to bottom and runs the first one whose exception type matches the error that was raised. Only one except block runs per exception.

def safe_divide(a, b):
    """Divide a by b, returning None on error."""
    try:
        result = a / b
    except ZeroDivisionError:
        print("Cannot divide by zero.")
        return None
    except TypeError:
        print(f"Both arguments must be numbers, got {type(a).__name__} and {type(b).__name__}.")
        return None
    else:
        print(f"{a} / {b} = {result}")
        return result
    finally:
        print("safe_divide() finished.")

safe_divide(10, 2)      # no error          → else runs, then finally
safe_divide(10, 0)      # ZeroDivisionError → first except runs, then finally
safe_divide(10, "two")  # TypeError         → second except runs, then finally

You can also catch two exception types in a single except clause by grouping them in a tuple:

user_input = "abc"   # simulating bad user input
denominator = 0      # simulating a zero denominator

try:
    value = int(user_input) / denominator
except (ValueError, ZeroDivisionError) as err:
    print(f"Input error: {err}")

Python Learning Summary Points

1. The try statement wraps code that might raise an exception. If an error occurs inside it, Python jumps to the matching except clause rather than crashing the program.
2. Always name the exception type in your except clause. A bare except: catches everything — including signals that are meant to stop your program — and hides real bugs.
3. Use else for code that depends on the try block succeeding, and use finally for cleanup that must run regardless of what happened.

The try statement is one of the first tools that separates code that works in a test environment from code that holds up in the real world. Once you are comfortable with the basic structure, explore raise to intentionally throw exceptions and with statements, which handle many common cleanup scenarios automatically.