zaro

What are the built in exceptions in Python?

Published in Python Exception Handling 6 mins read

Python's built-in exceptions are a set of predefined error classes that help developers identify and handle various issues that can occur during program execution. These exceptions are automatically raised by the Python interpreter when a specific error condition is met, providing a structured way to manage errors and prevent unexpected program termination.

What are Built-in Exceptions?

Built-in exceptions are standard errors defined within Python that cover a wide range of common problems, from syntax issues to runtime failures and system-level concerns. They are a fundamental part of Python's error handling mechanism, allowing programs to gracefully recover from errors or provide informative messages to the user.

The Role of Built-in Exceptions in Python

These exceptions serve several crucial roles:

  • Error Indication: They signal that something unexpected or erroneous has occurred.
  • Program Control Flow: They alter the normal flow of execution, allowing for specific error handling logic.
  • Debugging: The traceback provided with an exception offers valuable information for debugging.
  • Robustness: By catching and handling exceptions, programs can become more robust and resilient to unexpected inputs or conditions.

Common Categories of Built-in Exceptions

Python's extensive library of built-in exceptions can be broadly categorized based on the type of error they represent. Below is a comprehensive overview, including commonly occurring exceptions such as SyntaxError, ValueError, IOError, KeyboardInterrupt, ImportError, EOFError, ZeroDivisionError, IndexError, NameError, IndentationError, TypeError, and OverflowError.

Let's explore some of the most frequently encountered built-in exceptions:

1. Syntax and Indentation Errors

These errors occur before the program even begins to run, usually due to incorrect Python grammar or improper spacing.

  • SyntaxError:
    • Description: Raised when the parser encounters a syntax error, meaning the code is not valid Python.
    • Example: Missing a colon, unclosed parentheses.
    • # SyntaxError example
if True
    print("Hello")
  • IndentationError:
    • Description: A subclass of SyntaxError, raised when there is incorrect indentation, which is crucial in Python for defining code blocks.
    • Example: Inconsistent use of spaces and tabs, wrong indentation level.
    • # IndentationError example
def my_function():
print("Incorrect indentation")

2. Runtime Logic and Value Errors

These exceptions occur during the execution of the program due to invalid operations, incorrect data types, or issues with variable access.

  • TypeError:
    • Description: Raised when an operation or function is applied to an object of an inappropriate type.
    • Example: Adding a number to a string, calling a non-callable object.
    • # TypeError example
"hello" + 5
  • ValueError:
    • Description: Raised when an operation or function receives an argument that has the right type but an inappropriate value.
    • Example: Converting a non-numeric string to an integer, trying to remove an item not in a list.
    • # ValueError example
int("abc")
  • NameError:
    • Description: Raised when a local or global name is not found. This typically happens when a variable or function is used before it has been defined.
    • Example: Using an undefined variable.
    • # NameError example
print(undefined_variable)
  • AttributeError:
    • Description: Raised when an attribute reference or assignment fails. This often means trying to access a method or property that an object does not possess.
    • Example: Accessing a non-existent method of a string.
    • # AttributeError example
my_string = "hello"
my_string.non_existent_method()
  • ImportError:
    • Description: Raised when an import statement fails to find the module or when a name from a module cannot be loaded.
    • Example: Trying to import a non-existent module.
    • # ImportError example
import non_existent_module
    • ModuleNotFoundError: A subclass of ImportError, specifically raised when a module cannot be found.
  • IndexError:
    • Description: Raised when a sequence (like a list, tuple, or string) index is out of range.
    • Example: Accessing an element beyond the list's length.
    • # IndexError example
my_list = [1, 2, 3]
print(my_list[3])
  • KeyError:
    • Description: Raised when a dictionary key is not found.
    • Example: Trying to access a non-existent key in a dictionary.
    • # KeyError example
my_dict = {"name": "Alice"}
print(my_dict["age"])
  • ZeroDivisionError:
    • Description: Raised when the second operand of a division or modulo operation is zero.
    • Example: Dividing any number by zero.
    • # ZeroDivisionError example
result = 10 / 0
  • OverflowError:
    • Description: Raised when the result of an arithmetic operation is too large to be represented. This is less common in Python 3 for integers, which have arbitrary precision, but can occur with floating-point numbers.
    • Example: Calculation resulting in a number exceeding the maximum float value.
    • # OverflowError example (less common with integers in Python 3, more with floats)
import math
math.exp(1000) # This might raise OverflowError for floats
  • AssertionError:
    • Description: Raised when an assert statement fails. Assertions are typically used for internal self-checks in a program.
    • Example: An assertion condition evaluates to false.
    • # AssertionError example
x = 10
assert x > 100, "x must be greater than 100"

3. System and I/O Errors

These exceptions are related to interaction with the operating system, file system, or external resources.

  • OSError:
    • Description: Base class for OS-related errors. This covers a wide range of issues like file not found, permission denied, disk full, etc.
    • Note: IOError is a common term for input/output errors and in Python 3, it is an alias for OSError, meaning they refer to the same class.
    • Example: Attempting to open a non-existent file for writing in a restricted directory.
    • # OSError (or IOError) example
# This might raise FileNotFoundError (a subclass of OSError)
# or PermissionError (another subclass of OSError)
with open("/nonexistent/path/file.txt", "r") as f:
    content = f.read()
  • FileNotFoundError:
    • Description: A specific subclass of OSError, raised when a file or directory is requested but does not exist.
    • Example: Trying to open a file that doesn't exist.
    • # FileNotFoundError example
open("nonexistent_file.txt", "r")
  • EOFError:
    • Description: Raised when the input() function hits an end-of-file condition (EOF) without reading any data. This typically occurs in interactive sessions or when reading from a file that ends unexpectedly.
    • Example: Reading past the end of a file or receiving an EOF signal from an empty input stream.
    • # EOFError example (simulated, actual occurrence depends on input stream)
# In a script, this might not be easily reproducible without specific input handling
# It typically happens when raw_input() or input() reads an EOF
# e.g., if you run a script that expects input and you press Ctrl+D (Unix) or Ctrl+Z (Windows)
# without typing anything.
# input()
  • KeyboardInterrupt:
    • Description: Raised when the user hits the interrupt key (normally Ctrl+C or Delete). This is used to signal a request to terminate the program.
    • Example: Stopping an infinite loop or a long-running process manually.
    • # KeyboardInterrupt example
try:
    while True:
        pass # An infinite loop
except KeyboardInterrupt:
    print("\nProgram interrupted by user!")
  • SystemExit:
    • Description: Raised by the sys.exit() function. It's not typically caught by except Exception: blocks unless explicitly intended, as it's meant for clean program termination.
    • Example: Exiting a script intentionally.
    • # SystemExit example
import sys
sys.exit("Exiting program.")

Other Notable Built-in Exceptions

  • MemoryError: Raised when an operation runs out of memory.
  • RuntimeError: Raised when an error does not fall into any other category.
  • NotImplementedError: Raised by abstract methods in user-defined base classes when derived classes are expected to override the method.
  • StopIteration: Raised by the next() function and an iterator's __next__() method to signal that there are no further items produced by the iterator.

Understanding and effectively utilizing these built-in exceptions is crucial for writing robust, maintainable, and user-friendly Python applications.

← Previous Article
Is there a tax credit for homeschooling in Oklahoma?
Next Article →
What are the similarities between Scratch and Python?