26  Advanced Debugging: Mastering the Art of Code Divination

You’ve journeyed far in your quest for Python mastery, facing loops, conditionals, and the enigmatic realms of variables and data types. Now, it’s time to hone your debugging skills to a razor’s edge. Today, we delve deeper into the arcane art of debugging, unlocking powerful techniques to vanquish even the most elusive bugs.

26.1 The VSCode Debugger: Your Crystal Ball

VSCode’s debugger is like a magical crystal ball, allowing you to peer into the very soul of your code as it runs. Let’s learn how to harness its power:

  1. Setting Breakpoints:
    • Click in the left margin of your code to set a red dot (breakpoint).
    • Your code will pause here during debugging, letting you inspect everything.
  2. Starting the Debugger:
    • Click the “Run and Debug” icon in the left sidebar (it looks like a bug with a play button).
    • Select “Python File” to debug your current file.
  3. Stepping Through Code:
    • Use the control panel that appears to navigate your paused code:
      • Step Over (F10): Move to the next line.
      • Continue (F5): Run until the next breakpoint.
  4. Inspecting Variables:
    • The “Variables” pane shows the current state of all variables.
    • Hover over variables in your code to see their current values.

26.2 Debugging in Action: Parzival’s Treasure Hunt

Let’s debug a treasure hunt simulator:

import random

map_size = 5
treasure_x = random.randint(0, map_size - 1)
treasure_y = random.randint(0, map_size - 1)

attempts = 0
while True:
    guess_x = int(input(f"Enter X coordinate (0-{map_size-1}): "))
    guess_y = int(input(f"Enter Y coordinate (0-{map_size-1}): "))
    attempts += 1
    
    if guess_x == treasure_x and guess_y == treasure_y:
        print(f"Huzzah! You found the treasure in {attempts} attempts!")
        break
    else:
        print("Alas, no treasure here. Keep searching!")

To debug this:

  1. Set a breakpoint on the treasure_x = random.randint(0, map_size - 1) line.
  2. Start the debugger.
  3. When it pauses, inspect the map_size variable.
  4. Step through the code, watching how treasure_x and treasure_y are set.
  5. Continue execution and provide input when prompted.
  6. Use the debugger to watch how attempts increases and how the guesses are compared.

26.3 Advanced Techniques: Scrying the Code Streams

  1. Conditional Breakpoints: Right-click on a breakpoint and add a condition. The code will only pause when the condition is true. Example: Break when attempts > 10

  2. Logpoints: Instead of pausing, logpoints print a message to the console. Example: Log “Treasure not found” each time through the loop.

  3. Watch Expressions: Add complex expressions to the Watch pane to evaluate them as you step through code. Example: Watch abs(guess_x - treasure_x) + abs(guess_y - treasure_y) to see how close the guess is.

26.4 Debugging Loops and Conditionals: Untangling the Threads of Fate

Loops and conditionals can be tricky. Here are some tips:

  1. Loop Debugging:
    • Use a conditional breakpoint to pause on a specific iteration.
    • Watch loop variables to ensure they’re changing as expected.
  2. Conditional Debugging:
    • Set breakpoints inside each branch of an if-statement.
    • Use the debugger to understand how you reached a particular condition.

26.5 Best Practices: The Code Mage’s Wisdom

  1. Use Descriptive Variable Names: player_health is clearer than ph.
  2. Add Comments for Complex Logic: Future you will thank present you.
  3. Use Print Statements Strategically: Sometimes a well-placed print can illuminate issues.

26.6 Practice: Debug These Enchanted Scripts

  1. The Disappearing Dragon:

    dragons = ["Red", "Blue", "Green", "Gold"]
for i in range(len(dragons)):
    print(f"Defeating the {dragons[i]} dragon!")
    del dragons[i]
print("All dragons defeated!")

  2. The Cryptic Cauldron:

    ingredients = ["newt eyes", "dragon scale", "phoenix feather", "unicorn hair"]
cauldron = []
for item in ingredients:
    cauldron.append(item)
    if len(cauldron) = 3:
        print("Potion complete!")
        break
print("Potion incomplete...")
print(f"Final potion: {cauldron}")

  3. The Perplexing Palindrome:

    word = "racecar"
is_palindrome = True
for i in range(len(word) // 2):
    if word[i] != word[-i]:
        is_palindrome = False

if is_palindrome:
    print(f"{word} is a palindrome!")
else:
    print(f"{word} is not a palindrome.")

Use the VSCode debugger to find and fix the bugs in these scripts!

26.7 Common Debugging Pitfalls: Traps for the Unwary

  1. Debugging the Wrong Version: Ensure you’re running the saved file.
  2. Ignoring Warning Messages: They often hint at future errors.
  3. Assuming, Not Verifying: Always check your assumptions with the debugger.
  4. Debugging Too Much: Start with the first error; others might be consequences.

26.8 Conclusion and Further Enchantments

Congratulations, master debuggers! You’ve delved deep into the arcane arts of code divination. Remember, debugging is not just about fixing errors—it’s about understanding your code on a deeper level.

To further enhance your debugging prowess, consult these sacred scrolls:

  1. Official Python Debugging with VSCode
  2. Real Python’s Guide to the Python Debugger
  3. Python Debugging Techniques

May your code be ever bug-free, and your debugging skills ever sharp. Onward to greater coding adventures!