📘 Debugging Basics: print() Debugging and pdb

🎯 Introduction

Welcome to the wonderful world of debugging! 🎉 Have you ever stared at your code wondering why it’s not working? Don’t worry - we’ve all been there! In this guide, we’ll explore the art of finding and fixing bugs like a pro detective 🕵️‍♂️.

You’ll discover how debugging can transform your frustration into understanding. Whether you’re building web applications 🌐, games 🎮, or data analysis scripts 📊, mastering debugging is essential for becoming a confident Python developer.

By the end of this tutorial, you’ll know how to track down bugs like Sherlock Holmes! Let’s dive in! 🏊‍♂️

📚 Understanding Debugging

🤔 What is Debugging?

Debugging is like being a detective for your code 🔍. Think of it as investigating why your program isn’t behaving as expected - finding clues, following leads, and solving the mystery!

In Python terms, debugging helps you:

✨ Find where your code is breaking
🚀 Understand what values your variables hold
🛡️ Fix logic errors and edge cases

💡 Why Use Debugging?

Here’s why debugging is your best friend:

Save Time ⏰: Find bugs faster than guessing
Understand Code Flow 🔄: See exactly what’s happening
Learn Better 📖: Understand why things work (or don’t!)
Build Confidence 💪: Fix issues independently

Real-world example: Imagine building a shopping cart 🛒. With debugging, you can see exactly why the total isn’t calculating correctly!

🔧 Basic Syntax and Usage

📝 The Classic print() Debug

Let’s start with everyone’s first debugging tool:

# 👋 Hello, debugging!
def calculate_discount(price, discount_percent):
    print(f"🎯 Starting calculation: price={price}, discount={discount_percent}")  # Debug line
    
    discount_amount = price * discount_percent / 100
    print(f"💰 Discount amount: {discount_amount}")  # Debug line
    
    final_price = price - discount_amount
    print(f"✅ Final price: {final_price}")  # Debug line
    
    return final_price

# 🎮 Let's test it!
result = calculate_discount(100, 20)
print(f"🛒 Customer pays: ${result}")

💡 Explanation: Strategic print() statements show us the flow and values at each step!

🎯 Python Debugger (pdb)

Now let’s level up with Python’s built-in debugger:

import pdb

# 🏗️ Example: Finding a bug in list processing
def find_average(numbers):
    # 🐛 Set a breakpoint here
    pdb.set_trace()
    
    total = 0
    for num in numbers:
        total += num
    
    # 🎨 Another breakpoint to check the total
    average = total / len(numbers)
    return average

# 🔄 Test with data
scores = [85, 92, 78, 95, 88]
avg = find_average(scores)
print(f"📊 Average score: {avg}")

🎮 pdb Commands:

n (next): Execute next line
s (step): Step into functions
l (list): Show current code
p variable: Print variable value
c (continue): Continue execution
q (quit): Exit debugger

💡 Practical Examples

🛒 Example 1: Shopping Cart Bug Hunt

Let’s debug a real shopping cart issue:

# 🛍️ Shopping cart with a hidden bug
class ShoppingCart:
    def __init__(self):
        self.items = []
        self.total = 0
    
    def add_item(self, name, price, quantity):
        print(f"➕ Adding: {quantity}x {name} at ${price} each")  # Debug
        
        item = {
            'name': name,
            'price': price,
            'quantity': quantity
        }
        self.items.append(item)
        
        # 🐛 Bug alert! Let's debug this
        print(f"🔍 Before update - Total: ${self.total}")  # Debug
        self.total = price * quantity  # Bug: Should be +=
        print(f"🔍 After update - Total: ${self.total}")  # Debug
    
    def checkout(self):
        print(f"\n🛒 Cart contents:")
        for item in self.items:
            print(f"  {item['quantity']}x {item['name']} = ${item['price'] * item['quantity']}")
        print(f"💰 Total: ${self.total}")
        return self.total

# 🎮 Let's use it and find the bug!
cart = ShoppingCart()
cart.add_item("Python Book", 29.99, 1)
cart.add_item("Coffee Mug", 12.99, 2)
cart.add_item("Rubber Duck", 5.99, 3)  # For debugging, of course! 🦆
cart.checkout()

🎯 Can you spot the bug? The total is wrong because we’re overwriting instead of adding!

🎮 Example 2: Game Score Tracker Debug

Let’s debug a game scoring system:

import pdb

# 🏆 Score tracker with debugging
class GameScoreTracker:
    def __init__(self):
        self.players = {}
        self.high_score = 0
    
    def add_player(self, name):
        print(f"🎮 Adding player: {name}")  # Debug
        self.players[name] = {
            'score': 0,
            'level': 1,
            'lives': 3
        }
    
    def add_points(self, player, points):
        # 🐛 Debug checkpoint
        pdb.set_trace()
        
        if player in self.players:
            old_score = self.players[player]['score']
            self.players[player]['score'] += points
            new_score = self.players[player]['score']
            
            print(f"✨ {player}: {old_score} → {new_score} (+{points})")
            
            # 🏆 Check for high score
            if new_score > self.high_score:
                self.high_score = new_score
                print(f"🎊 NEW HIGH SCORE: {self.high_score}!")
            
            # 📈 Level up check
            if new_score >= self.players[player]['level'] * 100:
                self.level_up(player)
        else:
            print(f"❌ Player {player} not found!")
    
    def level_up(self, player):
        self.players[player]['level'] += 1
        self.players[player]['lives'] += 1  # Bonus life!
        print(f"🎉 {player} reached level {self.players[player]['level']}!")
    
    def show_scoreboard(self):
        print("\n📊 SCOREBOARD:")
        for name, data in self.players.items():
            print(f"  {name}: {data['score']} pts | Level {data['level']} | ❤️ x{data['lives']}")

# 🎮 Test the game tracker
game = GameScoreTracker()
game.add_player("Alice")
game.add_player("Bob")

# Play some rounds
game.add_points("Alice", 50)
game.add_points("Bob", 75)
game.add_points("Alice", 60)  # This should trigger level up!
game.add_points("Charlie", 100)  # This player doesn't exist!

game.show_scoreboard()

🚀 Advanced Concepts

🧙‍♂️ Advanced print() Debugging

When you’re ready to level up:

# 🎯 Advanced print debugging with decorators
def debug(func):
    def wrapper(*args, **kwargs):
        print(f"\n🔍 Calling {func.__name__}")
        print(f"📥 Args: {args}")
        print(f"📦 Kwargs: {kwargs}")
        
        result = func(*args, **kwargs)
        
        print(f"📤 Return: {result}")
        print(f"✅ {func.__name__} completed\n")
        return result
    return wrapper

# 🪄 Using the debug decorator
@debug
def calculate_magic_number(base, multiplier=2):
    result = base * multiplier
    return result

# 🚀 Automatic debugging!
magic = calculate_magic_number(21, multiplier=2)
print(f"✨ Magic number: {magic}")

🏗️ Advanced pdb Techniques

For the brave debuggers:

# 🚀 Conditional breakpoints
def process_data(items):
    for i, item in enumerate(items):
        # 🎯 Only break on specific conditions
        if item > 100:
            import pdb; pdb.set_trace()
        
        processed = item * 2
        print(f"Item {i}: {item} → {processed}")
    
    return "Processing complete! 🎉"

# 🎮 Test with mixed data
data = [10, 50, 150, 25, 200]  # Will break on 150 and 200
process_data(data)

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Forgetting to Remove Debug Prints

# ❌ Wrong way - leaving debug prints in production!
def calculate_tax(amount):
    print(f"DEBUG: amount = {amount}")  # 😰 Don't ship this!
    tax = amount * 0.1
    print(f"DEBUG: tax = {tax}")  # 😰 Or this!
    return tax

# ✅ Correct way - use a debug flag!
DEBUG = False  # Set to True when debugging

def calculate_tax(amount):
    if DEBUG:
        print(f"🔍 Amount: {amount}")
    
    tax = amount * 0.1
    
    if DEBUG:
        print(f"💰 Tax: {tax}")
    
    return tax

🤯 Pitfall 2: Not Understanding Variable Scope

# ❌ Dangerous - assuming variable exists
def process_user_data(users):
    for user in users:
        name = user.get('name')
        # 💥 What if 'age' key doesn't exist?
        age = user['age']  
    
    # 💥 'name' only exists inside the loop!
    print(f"Last user: {name}")  

# ✅ Safe - proper debugging and checks
def process_user_data(users):
    print(f"🔍 Processing {len(users)} users")  # Debug info
    
    last_name = None
    for user in users:
        name = user.get('name', 'Unknown')
        age = user.get('age', 0)  # Safe default
        
        print(f"👤 User: {name}, Age: {age}")  # Debug each user
        last_name = name
    
    if last_name:
        print(f"✅ Last user processed: {last_name}")

🛠️ Best Practices

🎯 Strategic Placement: Put debug prints at key decision points
📝 Clear Messages: Make debug output descriptive
🛡️ Use Debug Flags: Control debug output with variables
🎨 Format Nicely: Use f-strings and emojis for clarity
✨ Clean Up: Always remove debug code before committing

🧪 Hands-On Exercise

🎯 Challenge: Debug the Password Validator

Fix the bugs in this password validator:

📋 Requirements:

✅ Password must be 8+ characters
🔢 Must contain at least one number
🔤 Must contain uppercase and lowercase
🎨 Must contain a special character
🚫 No spaces allowed

def validate_password(password):
    # Add debug prints to find the bugs!
    
    # Check length
    if len(password) < 8:
        return False, "Too short!"
    
    # Check for number
    has_number = False
    for char in password:
        if char.isdigit():
            has_number = True
    
    # Check for uppercase/lowercase
    has_upper = password.isupper()  # Bug!
    has_lower = password.islower()  # Bug!
    
    # Check for special character
    special_chars = "!@#$%^&*"
    has_special = False
    for char in special_chars:
        if char in password:
            has_special = True
            break
    
    # Check for spaces
    if " " in password:
        return False, "No spaces allowed!"
    
    # Final validation
    if has_number and has_upper and has_lower and has_special:
        return True, "Password is strong! 💪"
    else:
        return False, "Password needs improvement"

# Test cases
passwords = [
    "short",
    "longenoughbutWeak",
    "GoodPass123!",
    "has spaces 123!A",
    "ALLUPPERCASE123!",
    "alllowercase123!"
]

for pwd in passwords:
    valid, message = validate_password(pwd)
    print(f"Password: '{pwd}' - {message}")

💡 Solution

🔍 Click to see solution

def validate_password(password):
    print(f"\n🔍 Validating: '{password}'")  # Debug entry
    
    # Check length
    print(f"  📏 Length: {len(password)}")  # Debug
    if len(password) < 8:
        return False, "Too short! Need 8+ characters"
    
    # Check for number
    has_number = any(char.isdigit() for char in password)
    print(f"  🔢 Has number: {has_number}")  # Debug
    
    # Check for uppercase/lowercase (FIXED!)
    has_upper = any(char.isupper() for char in password)
    has_lower = any(char.islower() for char in password)
    print(f"  🔤 Has upper: {has_upper}, Has lower: {has_lower}")  # Debug
    
    # Check for special character
    special_chars = "!@#$%^&*()_+-=[]{}|;:,.<>?"
    has_special = any(char in special_chars for char in password)
    print(f"  🎨 Has special: {has_special}")  # Debug
    
    # Check for spaces
    has_spaces = " " in password
    print(f"  🚫 Has spaces: {has_spaces}")  # Debug
    
    if has_spaces:
        return False, "No spaces allowed! 🚫"
    
    # Build feedback message
    missing = []
    if not has_number:
        missing.append("number")
    if not has_upper:
        missing.append("uppercase letter")
    if not has_lower:
        missing.append("lowercase letter")
    if not has_special:
        missing.append("special character")
    
    # Final validation
    if not missing:
        return True, "Password is strong! 💪🔒"
    else:
        return False, f"Password needs: {', '.join(missing)}"

# Test with improved feedback
print("🔐 Password Validator v2.0")
print("=" * 40)

passwords = [
    "short",
    "longenoughbutWeak",
    "GoodPass123!",
    "has spaces 123!A",
    "ALLUPPERCASE123!",
    "alllowercase123!",
    "Perfect123!"
]

for pwd in passwords:
    valid, message = validate_password(pwd)
    status = "✅" if valid else "❌"
    print(f"\n{status} Password: '{pwd}'\n   → {message}")

# Bonus: Interactive mode!
print("\n🎮 Try your own password:")
user_pwd = input("Enter password: ")
valid, message = validate_password(user_pwd)
print(f"\n{'✅' if valid else '❌'} {message}")

🎓 Key Takeaways

You’ve become a debugging detective! Here’s what you can now do:

✅ Use print() debugging strategically and effectively 💪
✅ Master pdb for interactive debugging 🛡️
✅ Track down bugs systematically 🎯
✅ Debug with confidence in any situation 🐛
✅ Write cleaner code by understanding flow better! 🚀

Remember: Every bug is a learning opportunity! Debugging isn’t about avoiding mistakes - it’s about learning from them. 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered debugging basics!

Here’s what to do next:

💻 Practice debugging your own code
🏗️ Try debugging a friend’s code (great learning!)
📚 Explore advanced debuggers like IPython’s %debug
🌟 Share your debugging tips with others!

Remember: Even expert programmers spend time debugging. The difference is they enjoy the detective work! Keep coding, keep debugging, and most importantly, have fun! 🚀

Happy debugging! 🎉🔍✨

Prerequisites

What you'll learn