Python Debugging Cheat Sheet

breakpoint()

# Pause execution and enter the configured debugger.

import pdb; pdb.set_trace()

# Classic explicit breakpoint using pdb.

python -m pdb app.py

# Start Python's debugger from the command line.

python -m pdb app.py --env dev --port 8000

# Pass normal program arguments when starting under pdb.

n

# Step over the current line without entering function calls.

s

# Step into a called function.

c

# Resume execution until the next breakpoint.

until

# Continue until a later line in the current frame.

l

# Show nearby source lines.

p variable_name

# Inspect the value of an expression.

pp complex_object

# Print structured data in a readable format.

w

# Display the current call stack.

u
d

# Navigate the traceback to inspect caller frames.

b app.py:42

# Break on a file and line number from within the debugger.

import traceback

try:
    risky_call()
except Exception:
    traceback.print_exc()

# Dump the active exception traceback in an except block.

import traceback

try:
    risky_call()
except Exception:
    error_text = traceback.format_exc()

# Capture traceback output for logs or APIs.

import sys

try:
    risky_call()
except Exception:
    exc_type, exc_value, exc_tb = sys.exc_info()

# Access exception type, value, and traceback explicitly.

try:
    parse_config()
except ValueError as exc:
    raise RuntimeError("Invalid configuration") from exc

# Chain exceptions to keep original failure context.

import faulthandler
faulthandler.enable()

# Print Python tracebacks on fatal errors like segfaults.

python -X faulthandler app.py

# Turn on fatal error tracebacks without code changes.

python -Wd app.py

# Enable warnings that may help reveal bad behavior.

python -X dev app.py

# Enable extra runtime checks and debug-friendly behavior.

print(type(obj))
print(dir(obj))

# Quickly see what an object is and what it exposes.

print(vars(obj))

# Show instance attributes stored on an object.

from pprint import pprint

pprint(payload)

# Display dicts and lists more readably.

import inspect

print(inspect.signature(func))

# See function parameters at runtime.

import inspect

print(inspect.getsource(func))

# Display source when available.

import sys

for path in sys.path:
    print(path)

# Debug why imports resolve incorrectly.

import package_name

print(package_name.__file__)

# Confirm which module file was actually imported.

import os

print(os.environ.get("APP_ENV"))

# Print environment values affecting program behavior.

import logging

logging.basicConfig(level=logging.DEBUG)
logging.debug("Starting debug run")

# Turn on debug-level logs quickly.

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s %(levelname)s %(name)s %(message)s',
)

# Add timestamps and levels to logs.

import logging

logger = logging.getLogger(__name__)

try:
    risky_call()
except Exception:
    logger.exception("Request processing failed")

# Emit the stack trace automatically in an except block.

import logging

base_logger = logging.getLogger(__name__)
logger = logging.LoggerAdapter(base_logger, {"request_id": request_id})
logger.info("Processing request")

# Add contextual identifiers that make debugging easier.

import time

start = time.perf_counter()
result = expensive_call()
elapsed = time.perf_counter() - start
print(f"Elapsed: {elapsed:.4f}s")

# Measure elapsed time around suspicious code paths.

python -m timeit "sum(range(1000))"

# Measure a small expression from the command line.

pytest -x

# Fail fast and debug one issue at a time.

pytest --pdb

# Open the debugger automatically when a test fails.

pytest -s

# See print statements and standard output live.

pytest tests/test_api.py::test_create_user

# Narrow execution to one failing test quickly.

pytest --lf

# Speed up debugging after a failing run.

pytest -vv --showlocals

# Reveal local state in failing assertions and exceptions.

python -m unittest -v tests.test_service

# See each test case as it runs.

python -m cProfile app.py

# Collect function-level runtime statistics.

python -m cProfile -s tottime app.py

# Surface slow functions first.

import cProfile
import pstats

profiler = cProfile.Profile()
profiler.enable()
expensive_call()
profiler.disable()
pstats.Stats(profiler).sort_stats('tottime').print_stats(20)

# Wrap a hot path in cProfile and print stats.

import tracemalloc

tracemalloc.start()
# run code
snapshot = tracemalloc.take_snapshot()
for stat in snapshot.statistics('lineno')[:10]:
    print(stat)

# Capture memory allocation snapshots.

import os
import psutil

process = psutil.Process(os.getpid())
print(process.memory_info())
print(process.cpu_percent(interval=1.0))

# Check runtime resource usage from inside the process.

PYTHONASYNCIODEBUG=1 python app.py

# Expose slow callbacks and event-loop issues.

import asyncio

async def main():
    ...

asyncio.run(main(), debug=True)

# Turn on event loop debugging in code.

python -m http.server 8000

# Serve files locally to reproduce client behavior.

python -X importtime app.py

# See which imports are slowing startup.

import faulthandler
import signal

faulthandler.register(signal.SIGUSR1)

# Useful when an app appears hung or deadlocked.