{"id":2654,"date":"2026-10-19T11:00:23","date_gmt":"2026-10-19T11:00:23","guid":{"rendered":"https:\/\/prwatech.in\/blog\/?p=2654"},"modified":"2026-10-20T06:21:17","modified_gmt":"2026-10-20T06:21:17","slug":"python-exception-handling-tutorial","status":"publish","type":"post","link":"https:\/\/prwatech.in\/blog\/python\/python-exception-handling\/python-exception-handling-tutorial\/","title":{"rendered":"Python Exception Handling Tutorial"},"content":{"rendered":"

Python Exception Handling Tutorial: try, except, else and finally<\/b><\/strong><\/h1>\n

A program that works on your own test data can still break the moment a real user touches it. Someone types a word where you expected a number. A file is missing. A network call times out. A list is shorter than you thought. Without any protection, Python stops at the first problem and prints a long message that means nothing to the user.<\/p>\n

Exception handling is how you stay in control when this happens. You tell Python which lines might fail, what to do if they do, and what must always run afterward, such as closing a file. Done well, a program turns a crash into a clear message or a safe fallback, and it keeps running.<\/p>\n

In this tutorial, we explain what an error and an exception are, and how Python reacts when one is not handled. We then go through the try and except blocks, handling more than one error, the else and finally blocks, the raise statement, custom exceptions, and file errors. Every program has been run. We finish with the order of except blocks, the exception hierarchy, and the mistakes to avoid.<\/p>\n

\"Python<\/p>\n

What is an Error in Python?<\/h2>\n

Python has two kinds of errors.<\/p>\n

    \n
  • Syntax errors<\/strong> are mistakes in how the code is written, such as a missing bracket. Python finds them before the program runs, and the program does not start at all.<\/li>\n
  • Exceptions<\/strong> are errors that happen while the program is running, even though the code is written correctly. Dividing by zero is one example. Python stops the current line, shows a message, and ends the program, unless you handle it.<\/li>\n<\/ul>\n
    \n
    python<\/div>\n
    try:\r\n    compile(\"print('hello'\", \"<test>\", \"exec\")\r\nexcept SyntaxError as e:\r\n    print(\"SyntaxError:\", e.msg)<\/pre>\n
    output<\/div>\n
    SyntaxError: '(' was never closed<\/pre>\n<\/div>\n
    The difference matters, because try and except can handle exceptions, and a syntax error is something you fix in the code.<\/p>\n
    Common Built In Exceptions<\/h2>\n
    These are the exceptions you will meet most, each with the real message Python gives.<\/p>\n
    \n\n\n\n\n\n\n\n\n\n\n\n
    Common exceptions and their messages<\/caption>\n
    Exception<\/th>\nWhen it happens<\/th>\nReal message<\/th>\n<\/tr>\n<\/thead>\n
    ZeroDivisionError<\/th>\nDividing by zero<\/td>\ndivision by zero<\/td>\n<\/tr>\n
    NameError<\/th>\nUsing a name that does not exist<\/td>\nname ‘undefined_name’ is not defined<\/td>\n<\/tr>\n
    IndexError<\/th>\nA list position is out of range<\/td>\nlist index out of range<\/td>\n<\/tr>\n
    KeyError<\/th>\nA dictionary key is missing<\/td>\n‘b’<\/td>\n<\/tr>\n
    ValueError<\/th>\nRight type, wrong value<\/td>\ninvalid literal for int() with base 10: ‘abc’<\/td>\n<\/tr>\n
    TypeError<\/th>\nWrong type for an operation<\/td>\ncan only concatenate str (not “int”) to str<\/td>\n<\/tr>\n
    FileNotFoundError<\/th>\nThe file does not exist<\/td>\n[Errno 2] No such file or directory<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    The Effect of Exception Handling<\/h2>\n
    An exception changes the normal flow of a program. When one is raised, Python stops running the lines in order and looks for a handler. If it finds an except block that matches, it runs that block and carries on after the whole try statement. If it finds none, the program ends right away and prints a traceback.<\/p>\n
    How Python Handles an Exception<\/h2>\n
    Python reads the try block line by line. If no line fails, the except blocks are skipped. If a line fails, Python jumps out of the try block at once, and the lines after the failing one do not run. It then picks the first except block that matches the error type.<\/p>\n
    Handling exceptions gives you three real benefits.<\/p>\n
      \n
    • Cleaner code.<\/strong> The normal path and the error path are separate, so you do not wrap every line in an if check.<\/li>\n
    • One consistent way to deal with errors.<\/strong> Every library you use reports problems in the same way.<\/li>\n
    • A program that does not crash.<\/strong> It can show a clear message, use a default, or try again.<\/li>\n<\/ul>\n
      Exception Handling Example<\/h2>\n
      The first print works. The second asks for index 4 in a list that has only four items, so Python raises an IndexError, and the except block runs.<\/p>\n
      \n
      python<\/div>\n
      test = [1, 2, 4, 8]\r\ntry:\r\n    print(\"First element = %d\" % (test[0]))\r\n    # Only 4 elements, so index 4 raises an IndexError\r\n    print(\"Fifth element = %d\" % (test[4]))\r\nexcept IndexError:\r\n    print(\"Error occurred\")<\/pre>\n
      output<\/div>\n
      First element = 1\r\nError occurred<\/pre>\n<\/div>\n
      Notice that the first line printed before the error, because the lines before the failure run normally.<\/p>\n
      Reading the Error Message<\/h3>\n
      You can catch the error as a variable with the word as<\/code>, and print the message Python gives. This helps when you need to know what went wrong.<\/p>\n
      \n
      python<\/div>\n
      try:\r\n    int(\"abc\")\r\nexcept ValueError as e:\r\n    print(\"Error:\", e)<\/pre>\n
      output<\/div>\n
      Error: invalid literal for int() with base 10: 'abc'<\/pre>\n<\/div>\n
      Multiple Exception Handling Example<\/h2>\n
      A block of code can fail in more than one way. You have two choices. You can catch several types in one except line, by putting them in round brackets as a tuple. Or you can write a separate except block for each type, so each error gets its own response.<\/p>\n
      One Handler for Several Errors<\/h3>\n
      The brackets are required. This example can fail in both ways. For the value 5, the division is by zero. For the text seven, Python cannot subtract a number from text.<\/p>\n
      \n
      python<\/div>\n
      def calculate(vari):\r\n    try:\r\n        cal = 100 \/ (vari - 5)\r\n        print(\"value of cal =\", cal)\r\n    except (ZeroDivisionError, TypeError):\r\n        print(\"Error handled\")\r\n \r\ncalculate(5)\r\ncalculate(7)\r\ncalculate(\"seven\")<\/pre>\n
      output<\/div>\n
      Error handled\r\nvalue of cal = 50.0\r\nError handled<\/pre>\n<\/div>\n
      A Separate Handler for Each Error<\/h3>\n
      When the right response is different for each error, give each its own block. Python checks them from top to bottom and runs only the first match.<\/p>\n
      \n
      python<\/div>\n
      def divide(a, b):\r\n    try:\r\n        result = a \/ b\r\n    except ZeroDivisionError:\r\n        print(\"You cannot divide by zero\")\r\n    except TypeError:\r\n        print(\"Both values must be numbers\")\r\n    else:\r\n        print(\"Result:\", result)\r\n    finally:\r\n        print(\"Division attempted\")\r\n \r\ndivide(10, 2)\r\ndivide(10, 0)\r\ndivide(10, \"2\")<\/pre>\n
      output<\/div>\n
      Result: 5.0\r\nDivision attempted\r\nYou cannot divide by zero\r\nDivision attempted\r\nBoth values must be numbers\r\nDivision attempted<\/pre>\n<\/div>\n
      At most one except block runs for each error.<\/p>\n
      The else and finally Statements<\/h2>\n
      Two optional blocks make a try statement more useful.<\/p>\n
      \n\n\n\n\n\n\n
      else and finally<\/caption>\n
      Block<\/th>\nWhen it runs<\/th>\nTypical use<\/th>\n<\/tr>\n<\/thead>\n
      else<\/th>\nOnly when the try block raised no exception<\/td>\nCode that should run only if everything worked<\/td>\n<\/tr>\n
      finally<\/th>\nAlways, whether or not there was an error<\/td>\nCleanup, such as closing a file or a connection<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
      The function below turns an age into days. For 20, nothing fails, so else and finally both run. For 20.5, the conversion to an int raises a ValueError, so the except block runs and then finally runs.<\/p>\n
      \n
      python<\/div>\n
      def print_age_in_days(years):\r\n    print(\"Your age in days is about\", 365 * int(years))\r\n \r\ndef check_age(age):\r\n    try:\r\n        print_age_in_days(age)\r\n    except ValueError:\r\n        print(\"You did not enter an age as a whole number\")\r\n    else:\r\n        print(age, \"successfully converted into days\")\r\n    finally:\r\n        print(\"Input test complete\")\r\n \r\ncheck_age(\"20\")\r\ncheck_age(\"20.5\")<\/pre>\n
      output<\/div>\n
      Your age in days is about 7300\r\n20 successfully converted into days\r\nInput test complete\r\nYou did not enter an age as a whole number\r\nInput test complete<\/pre>\n<\/div>\n
      In a real program the age would come from the input<\/code> function. We pass it in as text here so the example runs without waiting for typing.<\/p>\n
      Raise an Exception in Python<\/h2>\n
      So far Python raised the errors. You can also raise one yourself, with the raise<\/code> statement. This is how you reject bad data early, with a clear message, before it causes a confusing problem later.<\/p>\n
      The raise Statement<\/h3>\n
      \n
      python<\/div>\n
      def set_age(age):\r\n    if age < 0:\r\n        raise ValueError(\"Age cannot be negative\")\r\n    return age\r\n \r\ntry:\r\n    set_age(-5)\r\nexcept ValueError as e:\r\n    print(\"Error:\", e)<\/pre>\n
      output<\/div>\n
      Error: Age cannot be negative<\/pre>\n<\/div>\n
      The plainest form raises a NameError by hand, just to show the syntax:<\/p>\n
      \n
      python<\/div>\n
      try:\r\n    raise NameError(\"Python code\")\r\nexcept NameError as e:\r\n    print(\"Exception:\", e)<\/pre>\n
      output<\/div>\n
      Exception: Python code<\/pre>\n<\/div>\n
      Raising the Same Error Again<\/h3>\n
      A bare raise<\/code>, with nothing after it, inside an except block, sends the same exception up to the next handler. If there is no outer handler, Python runs the inner block and then stops with a traceback ending in NameError: Python code<\/code>. With an outer handler, it works as you would expect:<\/p>\n
      \n
      python<\/div>\n
      try:\r\n    try:\r\n        raise NameError(\"Python code\")\r\n    except NameError:\r\n        print(\"Inner handler ran\")\r\n        raise\r\nexcept NameError as e:\r\n    print(\"Outer handler caught:\", e)<\/pre>\n
      output<\/div>\n
      Inner handler ran\r\nOuter handler caught: Python code<\/pre>\n<\/div>\n
      Use this when a function wants to log or clean up after an error, and still let the caller decide what to do.<\/p>\n
      Create Your Own Exception<\/h2>\n
      When the built in exceptions do not describe your problem, make your own by writing a class that inherits from Exception<\/code>. It gives your error a clear name that the rest of the program can catch.<\/p>\n
      \n
      python<\/div>\n
      class LowBalanceError(Exception):\r\n    pass\r\n \r\ndef withdraw(balance, amount):\r\n    if amount > balance:\r\n        raise LowBalanceError(f\"Balance {balance} is less than {amount}\")\r\n    return balance - amount\r\n \r\ntry:\r\n    withdraw(500, 800)\r\nexcept LowBalanceError as e:\r\n    print(\"Custom error:\", e)<\/pre>\n
      output<\/div>\n
      Custom error: Balance 500 is less than 800<\/pre>\n<\/div>\n
      Opening Files and Exceptions<\/h2>\n
      Files are the most common place where exceptions happen, because a file can be missing, locked, or without permission. Opening a file that does not exist raises a FileNotFoundError<\/code>. This is a kind of OSError<\/code>. In Python 3, the name IOError<\/code> is only another name for OSError<\/code>.<\/p>\n
      The error object carries useful details. The attribute errno<\/code> is the error number, strerror<\/code> is the message, and filename<\/code> is the file that caused it.<\/p>\n
      \n
      python<\/div>\n
      try:\r\n    infile = open(\"Incorrect filename\")\r\nexcept OSError as ioe:\r\n    print(\"Unable to open the file\")\r\n    print(\"Error number\", ioe.errno)\r\n    print(\"Message\", ioe.strerror)\r\n    print(\"Filename in error\", ioe.filename)<\/pre>\n
      output<\/div>\n
      Unable to open the file\r\nError number 2\r\nMessage No such file or directory\r\nFilename in error Incorrect filename<\/pre>\n<\/div>\n
      Use with to Close Files Safely<\/h3>\n
      The with<\/code> statement closes the file for you, even when an error happens, so you do not need a finally block just for that.<\/p>\n
      \n
      python<\/div>\n
      try:\r\n    with open(\"notes_missing.txt\") as f:\r\n        data = f.read()\r\nexcept FileNotFoundError:\r\n    print(\"File not found, using default text\")<\/pre>\n
      output<\/div>\n
      File not found, using default text<\/pre>\n<\/div>\n