Common Built-in Exceptions

SyntaxError and IndentationError

These are the most fundamental exceptions because they prevent the Python interpreter from even parsing your code. A SyntaxError occurs when the structural rules of the language are violated, such as missing a colon after a control flow statement or an unbalanced parenthesis. Unlike runtime exceptions, these are typically caught by the parser before the program execution begins. An IndentationError is a specialized subclass of SyntaxError that specifically flags improper nesting within blocks, which is crucial since Python relies on whitespace to define scopes. Because the interpreter must understand the logic flow to execute it, these errors act as a fail-fast mechanism. When you encounter these, it usually means your code lacks the formal structure required to define a valid scope. Always check the line number provided by the traceback, as the actual error often precedes the flagged line, such as a missing closing bracket on the line above.

# Example of a SyntaxError caused by a missing colon
# def greeting()  # Missing colon here causes SyntaxError
#     print("Hello")

# Example of IndentationError caused by misaligned block
def check_logic():
    x = 10
  if x > 5:  # Improper indentation for this scope
        return True

NameError and UnboundLocalError

A NameError is raised when your code attempts to access a variable or function name that has not been defined in the current local or global scope. This happens when you try to reference an object before it exists or if you make a typo in the identifier name. Python's scoping rules determine how it searches for names, checking the local function scope first, then enclosing scopes, then the global module scope, and finally built-ins. If the search reaches the top without finding a match, the exception is triggered. A related issue is the UnboundLocalError, which occurs specifically when you try to use a local variable before it has been assigned a value within the same scope, particularly when trying to modify a global variable from inside a function without explicit keyword declaration. Reasoning about these errors requires you to verify your variable lifecycles and ensure that names are resolved before they are utilized in expressions.

# Triggering a NameError by referencing an undefined variable
# print(my_secret_variable)  # Raises NameError if not defined

def scope_test():
    # UnboundLocalError occurs if you try to increment a variable
    # without setting it locally first while attempting to modify it.
    # value += 1  # Raises UnboundLocalError if value is not defined
    value = 5
    return value + 1

TypeError and ValueError

These exceptions occur when operations are performed on incompatible objects. A TypeError signifies that an operation is applied to an object of an inappropriate type, such as attempting to add an integer to a string. Python is strongly typed, meaning it does not implicitly coerce types in ways that could lead to ambiguous results, forcing the developer to be explicit. Conversely, a ValueError occurs when an operation receives an argument that has the correct type but an inappropriate value. For example, passing a negative number to a mathematical function that only supports positive domains, or calling .pop() on an empty list. Understanding these differences is vital for robust API design. When you encounter these, you must decide whether to coerce your data into the expected format or add validation logic to prevent invalid data from ever reaching the sensitive operation, thus maintaining data integrity across your application's logic.

# TypeError: attempting to concatenate string and integer
# result = "Score: " + 100 

# ValueError: math.sqrt cannot accept a negative number
import math
try:
    print(math.sqrt(-1))  # Raises ValueError
except ValueError as e:
    print(f"Caught expected error: {e}")

IndexError and KeyError

These exceptions signal attempts to access elements in sequences or mappings that do not exist. An IndexError occurs when you try to access a sequence (like a list or tuple) at an index that is outside the valid range of its length. Since sequences are indexed starting from zero, the maximum valid index is always length minus one. A KeyError is the equivalent for mappings, such as dictionaries, raised when you attempt to access a key that is not present in the dictionary. These errors are highly common in data processing tasks. To prevent them, you should either implement boundary checking before access or utilize safe retrieval methods. For dictionaries, using the .get() method allows you to specify a default value instead of letting the program crash, which is a powerful pattern for handling missing configuration data or incomplete input payloads during execution.

# IndexError: accessing an index that doesn't exist
items = [1, 2, 3]
# print(items[5])  # Raises IndexError

# KeyError: accessing a non-existent dictionary key
config = {"port": 8080}
# print(config["host"])  # Raises KeyError

# Safe access using .get()
print(config.get("host", "localhost"))  # Returns default value

AttributeError and ImportError

An AttributeError arises when you try to access or modify an attribute or method that does not exist on a given object. This often happens if you assume an object is of a certain class when it is actually a different type, or if you misspell a method name. Because Python is dynamic, checking attributes often involves inspecting the object's dictionary or using reflection. An ImportError, however, occurs when you attempt to load a module that cannot be found or when a specific name cannot be imported from a module. This is usually related to issues with the system path, missing dependencies, or circular imports. Resolving these requires verifying your environment setup and ensuring that the module structure matches your import statements. By mastering these common errors, you gain the ability to debug complex application states and ensure your code is resilient against unexpected runtime environmental variations.

# AttributeError: accessing a method that doesn't exist
my_list = [1, 2]
# my_list.append_value(3)  # AttributeError: list has no such method

# ImportError: attempting to import a non-existent library
try:
    import non_existent_library
except ImportError:
    print("Module could not be loaded.")

Interview questions

All Python interview questions →

Check yourself

Take the full Python quiz →