Fix 7 Top Errors Causing Python Scripts to Crash (2025)

4. KeyError: Knocking on a Dictionary's Locked Door

A KeyError is the dictionary's version of an IndexError. It's raised when you try to access a value in a dictionary using a key that doesn't exist.

Common Scenario

This is common when processing data (like JSON from an API) where some keys might be optional.

user_profile = {
    "username": "cybersam",
    "level": 75
}

# The 'email' key does not exist
email = user_profile["email"]

# --- Traceback ---
# KeyError: 'email'

The Fix

Never access a potentially missing key directly. Instead, use the .get() method, which returns None (or a default value you provide) if the key is not found. This completely avoids the crash.

user_profile = {"username": "cybersam", "level": 75}

# Safe access using .get()
email = user_profile.get("email") # Returns None, no crash
print(f"Email: {email}")

# Safe access with a default value
status = user_profile.get("status", "offline")
print(f"Status: {status}")

# Output:
# Email: None
# Status: offline

Here's a quick comparison of IndexError and KeyError:

5. AttributeError: Asking an Object to Do the Impossible

An AttributeError occurs when you try to access or call an attribute or method that doesn't exist on an object. For example, trying to .append() to an integer or .keys() on a list.

Common Scenario

This often happens when a function returns an unexpected type (like None instead of a list) and the subsequent code tries to operate on it as if it were the expected type.

def get_users(active_only=True):
    # Imagine this sometimes returns None if the database is down
    if db_is_offline:
        return None
    return ["user1", "user2"]

active_users = get_users()
# If get_users() returned None, this next line will fail
active_users.append("user3")

# --- Traceback ---
# AttributeError: 'NoneType' object has no attribute 'append'

The Fix

Always validate the object you're working with before you try to call its methods. A simple check can prevent the crash.

active_users = get_users()

# Check if we got a valid list before using it
if active_users is not None:
    active_users.append("user3")
    print(f"Updated Users: {active_users}")
else:
    print("Could not retrieve users.")

6. ModuleNotFoundError / ImportError: The Lost Library

ModuleNotFoundError (a subclass of ImportError) is raised when Python cannot find a module you're trying to import. This is a common headache when setting up projects or moving them between environments.

Common Scenario

You try to import a library that you haven't installed in your current Python environment, or you make a typo in the import statement.

# We want to use the popular 'requests' library
import request # Typo! It's 'requests'

# --- OR ---

# We haven't installed 'pandas' yet
import pandas

# --- Traceback ---
# ModuleNotFoundError: No module named 'request'

The Fix

This requires a checklist approach:

1. Check for Typos: Is the module name spelled correctly? (e.g., pandas, not panda; requests, not request).
2. Check Installation: Is the package installed? Run pip install <package_name> in your terminal (e.g., pip install requests).
3. Check Your Environment: Are you running the script with the same Python environment (e.g., virtual environment) where you installed the package? This is the most common cause in larger projects. Make sure your virtual environment is activated.
4. Check sys.path: For your own local modules, ensure the directory containing the module is in Python's search path.

7. FileNotFoundError: The Phantom File

Any script that interacts with the file system is at risk of this error. FileNotFoundError is raised when you try to open or operate on a file that doesn't exist at the specified path.

Common Scenario

You're trying to read a configuration file or a data file, but the path is wrong, or the file hasn't been created yet.

# This script expects a config file in the same directory
with open("config.json", "r") as f:
    config_data = f.read()

# --- Traceback ---
# FileNotFoundError: [Errno 2] No such file or directory: 'config.json'

The Fix

The robust way to handle this is with a try...except block. This allows your program to handle the missing file gracefully—perhaps by creating a default one, or by informing the user and exiting cleanly.

import os

config_path = "config.json"

try:
    with open(config_path, "r") as f:
        config_data = f.read()
    print("Configuration loaded successfully.")
except FileNotFoundError:
    print(f"Error: '{config_path}' not found. Using default settings.")
    # You could set default values here instead of crashing
    config_data = "{}"

Pro-Tip: Use the pathlib module for modern, object-oriented path manipulation. You can check for existence easily with pathlib.Path('config.json').exists().

Conclusion: From Debugging to Defensive Driving

Errors are an inevitable part of software development. The seven we've covered—from NameError to FileNotFoundError—represent a huge percentage of the crashes you'll encounter in the wild. By learning to recognize them, you can dramatically cut down your debugging time.

The ultimate goal is to move from reactive debugging to proactive, defensive coding. Anticipate that a dictionary key might be missing and use .get(). Expect that a file might not exist and wrap it in a try...except block. Assume a function might return None and check for it. This mindset shift doesn't just prevent crashes; it's the hallmark of a mature, professional developer. So the next time you see a traceback, don't despair. See it as a puzzle, a lesson, and a stepping stone to writing better, more resilient Python code.