Python Debugging Techniques for Beginners | Step-by-Step Guide

# Example that generates an error
def calculate_average(numbers)
    total = sum(numbers)
    return total / len(numbers)

# Running this gives:
#   File "example.py", line 1
#     def calculate_average(numbers)
#                                   ^
# SyntaxError: expected ':'

Step 2: Use Print Statements as Your Flashlight

When you’re in a dark room, you use a flashlight to see what’s there. When you’re debugging, print() statements are your flashlight.

Add print statements throughout your code to check:

• What values your variables actually contain
• Whether a function is being called at all
• What path your code takes in if/else conditions
• The state of your data before and after operations
   

def process_student_grades(grades):
    print(f"Input grades: {grades}")  # What came in?
    print(f"Type of grades: {type(grades)}")  # Is it a list?

    total = 0
    count = 0

    for grade in grades:
        print(f"Processing grade: {grade}")  # Each item
        total += grade
        count += 1
        print(f"Running total: {total}")  # Watch it build

    average = total / count
    print(f"Final average: {average}")  # What's coming out?
    return average

# Test it
grades = [85, 90, 78, 92]
result = process_student_grades(grades)

Why it matters: You can’t fix what you can’t see. Print statements reveal the hidden state of your program and confirm whether your assumptions about the code are correct.

Common use cases:

• Print inside loops to see each iteration
• Print before and after function calls
• Print inside conditionals to see which branch executes

Step 3: Comment Out Code to Isolate the Problem

When your program isn’t working and you have no idea why, start commenting out sections until you find the culprit.

This technique works like a binary search for bugs. Comment out half your code. Does the error still happen? If yes, the bug is in the remaining half. If no, it’s in the commented half. Keep narrowing down until you find the exact line.

def complex_data_processing(data):
    # Step 1: Clean the data
    # cleaned = [item.strip().lower() for item in data if item]
    # print(f"Cleaned: {cleaned}")

    # Step 2: Filter valid entries
    # valid = [item for item in cleaned if len(item) > 3]
    # print(f"Valid: {valid}")

    # Step 3: Convert to dictionary
    # result_dict = {item: len(item) for item in valid}
    # print(f"Dictionary: {result_dict}")

    # Step 4: Calculate statistics (temporarily return simple value)
    return "Testing - all commented out"

    # Step 5: Final processing (this never runs right now)
    # return process_statistics(result_dict)

Start with all code commented except the bare minimum. Then uncomment sections one by one, testing after each addition. When the error suddenly appears, you’ve found the problematic section.

Why it matters: Complex programs have too many moving parts to debug all at once. Isolation reduces the problem space dramatically.

Step 4: Check Your Assumptions About Data Types

One of the most common python coding mistakes beginners make is assuming data is in a format it’s not. Python is dynamically typed, which is flexible but can hide type issues until runtime.

Always verify your data types when things aren’t working:

def calculate_grade_percentage(scores):
    # Check your assumptions!
    print(f"Type of scores: {type(scores)}")

    # What if scores is a string instead of a list?
    if isinstance(scores, str):
        print("Warning: scores is a string, converting to list")
        scores = [int(x) for x in scores.split(',')]

    # What if scores contains strings instead of numbers?
    for i, score in enumerate(scores):
        if isinstance(score, str):
            print(f"Converting string '{score}' to int at position {i}")
            scores[i] = int(score)

    return sum(scores) / len(scores)

# Test with different inputs
print(calculate_grade_percentage([85, 90, 78]))
print(calculate_grade_percentage("85,90,78"))
print(calculate_grade_percentage([85, "90", 78]))

Why it matters: Many errors happen not because your logic is wrong, but because your data isn’t what you expected. A list of strings behaves very differently from a list of integers.

 

💡 Pro Tip: Use type() and isinstance() liberally when debugging. They’re like x-ray vision for your variables.

 

Step 5: Use Python’s Built-in Debugger (pdb)

When print statements aren’t enough, it’s time to bring in the professionals. Python comes with a built-in debugger called pdb that lets you pause your program and inspect it interactively.

To use pdb, just add this line where you want to start debugging:

import pdb; pdb.set_trace()

When your program hits this line, it stops and gives you an interactive prompt where you can:

• Type variable names to see their values
• Step through code line by line
• Continue execution until the next breakpoint
   

def analyze_student_performance(students):
    results = []

    for student in students:
        name = student['name']
        grades = student['grades']

        # Start debugging here
        import pdb; pdb.set_trace()

        # Calculate average (we'll inspect before this runs)
        average = sum(grades) / len(grades)

        if average >= 90:
            results.append(f"{name}: A")
        elif average >= 80:
            results.append(f"{name}: B")
        else:
            results.append(f"{name}: Needs improvement")

    return results

# Test data
class_data = [
    {'name': 'Alice', 'grades': [95, 88, 92]},
    {'name': 'Bob', 'grades': [78, 82, 80]},
]

analyze_student_performance(class_data)

When the debugger stops, you can type:

• name to see what’s in the name variable
• grades to examine the grades list
• n to execute the next line
• c to continue running normally
• q to quit debugging
  Why it matters: pdb gives you complete control over execution. You can inspect exactly what’s happening at the moment it happens, which is invaluable for complex logic errors.

Step 6: Use IDE Debugging Tools

If you’re using an IDE like PyCharm, VS Code, or Thonny (popular for beginners), you have visual debugging tools that are even easier than pdb.

Most IDEs let you:

• Click next to line numbers to set breakpoints (where execution pauses)
• Run your program in debug mode
• See all variable values in a panel as you step through code
• Evaluate expressions on the fly
  Here’s how to use VS Code debugging effectively:

1. Click in the gutter (left of line numbers) to set a red dot breakpoint
2. Press F5 to start debugging
3. Use the debugging toolbar to step over, step into, or step out of functions
4. Watch variables update in real-time in the debug sidebar
    

# Set a breakpoint on the line below
def fibonacci(n):
    if n <= 1:
        return n

    a, b = 0, 1
    for i in range(2, n + 1):
        # Breakpoint here to watch the values change
        a, b = b, a + b
        print(f"Step {i}: a={a}, b={b}")

    return b

# Test the function
result = fibonacci(10)
print(f"Result: {result}")

Why it matters: Visual debugging is like having a microscope for your code. You can watch variables change, see exactly when conditions become true, and understand the flow of your program without adding a million print statements.

Step 7: Rubber Duck Debugging

Sometimes the best python debugging tool isn’t technical at all. Rubber duck debugging is the practice of explaining your code, line by line, to an inanimate object (traditionally a rubber duck).

Here’s how it works:

1. Get a rubber duck (or any object, or even just talk to yourself)
2. Explain your code out loud, line by line, as if teaching someone
3. When you get to the problematic section, you’ll often realize the mistake yourself
   python

def find_largest(numbers):
    # "Okay duck, first I set largest to the first number"
    largest = numbers[0]

    # "Then I loop through all numbers in the list"
    for num in numbers:
        # "If the current number is bigger than largest..."
        if num > largest:
            # "...I update largest to be that number"
            largest = num

            # Wait a minute, duck... I'm updating largest inside the loop
            # but I'm also using largest in the comparison condition.
            # That's fine, but am I handling empty lists?
            # What if numbers is empty? numbers[0] would cause an error!

    return largest

Why it matters: Speaking out loud forces your brain to process information differently than silent reading. You’ll catch assumptions you didn’t realize you were making and logical leaps that seemed fine in your head.

4. Common Mistakes

Mistake 1: Ignoring the Full Error Traceback

What it looks like: You see “Error” and immediately scroll up to your code to start guessing.
Why students make it: The red text looks scary and technical.
How to avoid it: Train yourself to read from the bottom up. The last line tells you the error type. The lines above show you the exact path your code took before crashing.

Mistake 2: Trying to Fix Everything at Once

What it looks like: You have five different errors, so you change ten lines of code, rerun, and now you have seven errors.
Why students make it: The desire to just “get it working” leads to scattered, desperate changes.
How to avoid it: Fix one error at a time. Run the code after each fix. Use version control (like Git) so you can undo changes that make things worse.

Mistake 3: Forgetting That Input() Returns Strings

What it looks like:

age = input("Enter your age: ")
if age >= 18:  # TypeError: '>=' not supported between str and int
    print("Adult")

Why students make it: The input() function always returns a string, even if the user types numbers.
How to avoid it: Convert input immediately: age = int(input(“Enter your age: “)) and handle potential errors where users might enter non-numbers.

Mistake 4: Misunderstanding Variable Scope

What it looks like:

def update_score(new_points):
    score += new_points  # UnboundLocalError
    return score

score = 10
update_score(5)

Why students make it: Variables defined outside functions aren’t automatically accessible inside functions for modification.
How to avoid it: Pass variables as parameters or use the global keyword (though passing parameters is cleaner).

Mistake 5: Off-by-One Errors in Loops

What it looks like:

# Trying to print all items in a list
items = [1, 2, 3, 4, 5]
for i in range(1, len(items)):  # Starts at 1, misses items[0]
    print(items[i])

Why students make it: Humans count from 1, but Python indexes from 0.
How to avoid it: Remember that range(len(items)) gives indices 0 through len(items)-1. When in doubt, print the indices you’re actually using.

Mistake 6: Not Using Print Statements Strategically

What it looks like: Adding 20 print statements, running the code, and being overwhelmed by the output.
Why students make it: “More information must be better, right?”
How to avoid it: Add print statements strategically around suspicious areas. Label your output: print(f”Inside calculate_average, grades = {grades}”) so you know exactly where each print comes from.

5. FAQ Section

Q: Why does Python give me an error on a line that looks perfectly fine?

A: Often the actual error happened earlier, but Python only realizes something’s wrong when it reaches that line. For example, forgetting a closing parenthesis on a previous line might cause an error on the next line. Always check the line before the error marker too.

Q: What’s the difference between SyntaxError and NameError?

A: A SyntaxError means you wrote something Python can’t understand at all—like forgetting a colon or mismatched quotes. A NameError means Python understands your syntax, but you’re using a variable name that doesn’t exist (maybe you misspelled it or forgot to define it).

Q: How do I debug an infinite loop without crashing my computer?

A: In most IDEs and terminals, press Ctrl+C to interrupt the program. Then add a print statement inside the loop to see what’s happening, or add a counter that breaks after a certain number of iterations while you debug.

Q: My code works on my computer but not on the autograder. Why?

A: This is incredibly common! Check for: different Python versions, file paths that might not exist on the autograder, whitespace issues in input files, or assuming the autograder will provide input in a specific order. Always match your development environment to the grading environment.

Q: Should I use a debugger or print statements?

A: Both! Print statements are quick and great for simple issues. Debuggers give you more control for complex problems. As you get more comfortable, you’ll naturally use both depending on the situation.

Q: How do I debug code that uses random numbers?

A: Set a fixed seed at the top of your program during debugging: import random; random.seed(42). This ensures the “random” numbers are the same every time you run, making bugs reproducible.

Q: What’s the most common Python mistake beginners make?

A: Indentation errors. Python uses indentation to determine code blocks, so mixing tabs and spaces or inconsistent indentation causes confusing errors. Set your editor to convert tabs to spaces automatically.

Q: How do I debug when my code just doesn’t output anything?

A: Your program might be waiting for input, stuck in a loop, or just running very slowly. Add a print statement at the very beginning to confirm the program starts. Then add more prints to see how far it gets before hanging.

6. Conclusion

Debugging isn’t a sign that you’re a bad programmer. It’s proof that you’re a real programmer. Every developer, from first-year students to senior engineers at Google, spends a significant portion of their time finding and fixing bugs.

The python debugging techniques for beginners you’ve learned here form a systematic approach to problem-solving:

• Read error messages carefully
• Use print statements as your flashlight
• Isolate problems by commenting code
• Check your data type assumptions
• Leverage debugging tools like pdb and IDEs
• Explain your code to a rubber duck
   

Start with these techniques today. The next time you see an error message, don’t panic. Take a breath, read what it’s telling you, and apply these steps systematically. Each bug you fix makes you a stronger, more confident programmer.

Ready to submit that assignment with confidence? Get expert help with your code:

• Submit your assignment for code review – Our tutors will review your code, identify bugs, and explain how to fix them.
• Book a one-on-one tutoring session – Get personalized help with debugging, concepts, or complete assignments.
• Read more articles on our blog for more programming tips and study strategies.