Part 3: Variables, Watch, and Data Inspection

Introduction

You've set breakpoints and paused execution—now what? The real power of debugging comes from inspecting your application's state: variables, objects, data structures, and call stacks.

I once spent 2 hours debugging why an API returned incorrect data. The problem? A nested dictionary three levels deep had the wrong structure. The Variables panel showed me the entire object tree in 30 seconds. This article teaches you how to inspect, evaluate, and understand data during debugging.

The Variables Panel

When execution pauses, the Variables panel shows all variables in the current scope.

Understanding Scope Sections

def calculate_order_total(order_id, user_id):
    # Breakpoint on next line
    order = get_order(order_id)
    user = get_user(user_id)
    
    subtotal = sum(item['price'] * item['qty'] for item in order['items'])
    discount = get_user_discount(user)
    total = subtotal - discount
    
    return total

Variables panel shows:

VARIABLES
  ▼ Locals
    order_id: 12345
    user_id: 67890
    order: {...}
    user: {...}
    subtotal: 199.99
    discount: 19.99
    total: 180.00
    
  ▼ Globals
    __name__: "__main__"
    calculate_order_total: <function>
    get_order: <function>
    get_user: <function>

• Locals: Variables in the current function

• Globals: Module-level variables and imports

Inspecting Complex Objects

Click the triangle to expand objects:

VARIABLES
  ▼ Locals
    ▼ order
      order_id: 12345
      status: "pending"
      ▼ items: [...]
        ▶ 0: {...}
        ▶ 1: {...}
        ▶ 2: {...}
      ▼ customer
        id: 67890
        name: "Alice Johnson"
        ▼ address
          street: "123 Main St"
          city: "Portland"
          zip: "97201"

Real scenario: I was debugging why shipping calculations were wrong. Expanded the order object and found:

▼ order
  ▼ shipping_address
    street: None  ← Bug! Using billing address instead
    city: None
    zip: None

Modifying Variables During Debugging

You can change variable values while debugging!

Right-click variable → "Set Value"

def apply_discount(price, discount_percent):
    discount = price * (discount_percent / 100)  # ← Breakpoint here
    # discount_percent is 150 (bug - should be 15)
    final_price = price - discount
    return final_price

At breakpoint:

1. See discount_percent: 150 in Variables panel

2. Right-click discount_percent → "Set Value"

3. Enter 15

4. Continue debugging to test if fix works

Perfect for: Testing fixes without restarting the entire debug session.

Filtering Variables

With many variables, use the filter box (⌥⌘F while focused on Variables):

VARIABLES (filter: "user")
  ▼ Locals
    user_id: 67890
    user: {...}
    user_discount: 10.0

The Watch Panel

Monitor specific expressions that update as you step through code.

Adding Watch Expressions

def process_cart(items, tax_rate):
    subtotal = 0
    
    for item in items:  # ← Breakpoint here
        subtotal += item['price'] * item['quantity']
    
    tax = subtotal * tax_rate
    total = subtotal + tax
    
    return total

Watch expressions:

WATCH
  len(items)           → 5
  subtotal             → 157.50
  subtotal * tax_rate  → 13.3875
  sum(i['price'] for i in items)  → 157.50

Watch expressions update as you step through code. Perfect for tracking calculations!

Real Example: Debugging a Pricing Bug

def calculate_subscription_price(user, plan):
    base_price = plan['monthly_price']
    
    # Watch: base_price
    # Watch: user.get('discount_rate', 0)
    # Watch: base_price * (1 - user.get('discount_rate', 0))
    
    if user.get('is_annual', False):
        discount_rate = 0.20
    else:
        discount_rate = user.get('discount_rate', 0)
    
    # Watch updates here!
    final_price = base_price * (1 - discount_rate)
    
    return final_price

As I stepped through, watch panel showed:

WATCH
  base_price                                → 29.99
  user.get('discount_rate', 0)              → 0.15
  base_price * (1 - discount_rate)          → 25.49  (updating!)
  user.get('is_annual', False)              → True

Saw immediately that annual discount overwrote the user's discount instead of stacking.

Advanced Watch Expressions

Watch panel accepts any Python expression:

# Check data types
type(user)

# Check lengths
len(items)

# Call methods
user.get('email', 'N/A').lower()

# List comprehensions
[item['id'] for item in items if item['active']]

# Complex calculations
sum(item['price'] * item['qty'] for item in cart['items'])

# Check if None
user is None

# Dictionary access with default
config.get('timeout', 30)

Copying Values from Watch

Right-click watch expression:

• Copy Value: Copy the result value

• Copy as Expression: Copy the expression itself

Useful for:

• Pasting values into code

• Sharing debugging info

• Testing expressions in debug console

Call Stack Inspection

The call stack shows the sequence of function calls that led to the current line.

Understanding the Call Stack

def main():
    result = process_order(order_id=123)  # ← Call 1
    
def process_order(order_id):
    order = validate_order(order_id)       # ← Call 2
    
def validate_order(order_id):
    items = check_inventory(order_id)     # ← Call 3
    
def check_inventory(order_id):
    stock = get_stock_levels()             # ← Call 4 (currently paused here)

Call stack shows:

CALL STACK
  check_inventory (inventory.py:45)     ← You are here
  validate_order (orders.py:23)
  process_order (orders.py:12)
  main (main.py:5)
  <module> (main.py:50)

Navigating the Call Stack

Click any frame in the call stack to see:

• Variables in that frame's scope

• Source code at that point

• State when that function was called

Real scenario: Exception in check_inventory(). Call stack showed:

CALL STACK
  ▶ check_inventory (inventory.py:45)  ← Exception here
  ▶ validate_order (orders.py:23)
    Variables: order_id=123, items=None
  ▶ process_order (orders.py:12)
    Variables: order_id=123, user_id=456

Clicked process_order frame and saw user_id=456, which helped me understand the context of the error.

Call Stack for Async Code

Python async code shows in call stack differently:

async def handle_request(request):
    data = await fetch_data(request.id)  # ← Paused here
    
async def fetch_data(item_id):
    return await db.query(item_id)

Call stack:

CALL STACK
  fetch_data (api.py:15)
  handle_request (api.py:8)
  <coroutine wrapper>
  <event loop>

Shows async call hierarchy clearly.

Debug Console REPL

The debug console isn't just for viewing—it's a full Python REPL running in your code's context.

Exploring Object Structure

def transform_api_response(response):
    data = response.json()  # ← Breakpoint here
    return format_data(data)

Debug console:

>>> type(data)
<class 'dict'>

>>> data.keys()
dict_keys(['status', 'results', 'pagination', 'metadata'])

>>> data['results'][0]
{'id': 1, 'name': 'Product A', 'price': 29.99}

>>> len(data['results'])
25

>>> [r['price'] for r in data['results']]
[29.99, 39.99, 19.99, ...]

All without modifying your code!

Testing Code Fixes

def format_username(first, last, middle=None):
    # Bug: middle name causes issues
    if middle:
        return f"{first} {middle[0]}. {last}"  # ← Breakpoint
    return f"{first} {last}"

Debug console - test fix:

>>> first
'John'
>>> middle
''  # ← Empty string, not None!

>>> if middle:
...     print("Bug!")
Bug!

# Test fix:
>>> if middle and len(middle) > 0:
...     formatted = f"{first} {middle[0]}. {last}"
... else:
...     formatted = f"{first} {last}"
>>> formatted
'John Doe'  # ← Works!

Now update the code with confidence.

Running Complex Queries

def filter_active_users(users):
    return [u for u in users if u['active']]  # ← Breakpoint

Debug console:

>>> len(users)
1523

>>> sum(1 for u in users if u['active'])
892

>>> sum(1 for u in users if u['active'] and u['premium'])
134

>>> [u['email'] for u in users if u['role'] == 'admin']
['[email protected]', '[email protected]']

>>> from collections import Counter
>>> Counter(u['role'] for u in users)
Counter({'user': 1389, 'admin': 12, 'moderator': 122})

Explore data interactively!

Importing Modules in Debug Console

def analyze_data(records):
    # Need to inspect dates
    data = load_records()  # ← Breakpoint

Debug console:

>>> from datetime import datetime, timedelta
>>> from collections import Counter

>>> dates = [r['created_at'] for r in records]
>>> Counter(d.strftime('%Y-%m') for d in dates)
Counter({'2024-01': 45, '2024-02': 67, '2024-03': 89})

>>> recent = [r for r in records if r['created_at'] > datetime.now() - timedelta(days=7)]
>>> len(recent)
23

Full Python environment at your fingertips!

Real-World Example: Debugging a Data Pipeline

I built a data processing pipeline that transformed customer records. Output had inconsistent data.

The Code

from typing import List, Dict
from datetime import datetime

def process_customer_batch(raw_records: List[Dict]) -> List[Dict]:
    """Transform raw customer records into standardized format"""
    processed = []
    
    for record in raw_records:  # ← Breakpoint here
        customer = {
            'id': record['customer_id'],
            'name': format_name(record),
            'email': record.get('email', '').lower().strip(),
            'phone': format_phone(record.get('phone')),
            'created': parse_date(record['created_at']),
            'lifetime_value': calculate_ltv(record),
            'segment': determine_segment(record)
        }
        processed.append(customer)
    
    return processed

def format_name(record):
    first = record.get('first_name', '')
    last = record.get('last_name', '')
    return f"{first} {last}".strip()

def format_phone(phone):
    if not phone:
        return None
    return ''.join(c for c in phone if c.isdigit())

def parse_date(date_str):
    return datetime.fromisoformat(date_str)

def calculate_ltv(record):
    orders = record.get('orders', [])
    return sum(o.get('total', 0) for o in orders)

def determine_segment(record):
    ltv = calculate_ltv(record)
    if ltv > 1000:
        return 'vip'
    elif ltv > 500:
        return 'regular'
    return 'new'

Problem: Some customers had wrong segments and missing data.

Debugging Session

Set Conditional Breakpoint

Only pause on customers with issues:

Breakpoint on line 9 (for loop) Condition: record.get('customer_id') == 'CUST-12345'

Inspect Record Structure

>>> record
{
    'customer_id': 'CUST-12345',
    'first_name': 'Alice',
    'last_name': 'Johnson',
    'email': ' [email protected] ',
    'phone': '[phone]',
    'created_at': '2024-01-15T10:30:00',
    'orders': [
        {'order_id': 'ORD-1', 'total': 150.50},
        {'order_id': 'ORD-2', 'total': None},  ← Bug!
        {'order_id': 'ORD-3', 'total': 75.25}
    ]
}

Use Watch Panel

Added watch expressions:

WATCH
  len(record.get('orders', []))                     → 3
  sum(o.get('total', 0) for o in record['orders'])  → TypeError!
  [o for o in record['orders'] if o.get('total')]   → Shows 2 orders
  calculate_ltv(record)                              → TypeError

Watch panel showed the error immediately—total: None caused TypeError in sum().

Test Fix in Debug Console

>>> orders = record.get('orders', [])
>>> sum(o.get('total', 0) for o in orders if o.get('total') is not None)
225.75

# Better fix with default:
>>> sum(o.get('total') or 0 for o in orders)
225.75

Verify Full Flow

Step through with F10:

VARIABLES (after each step)
  customer.id       → 'CUST-12345'
  customer.name     → 'Alice Johnson'
  customer.email    → '[email protected]'  ← Fixed (lowercased, stripped)
  customer.phone    → '5551234567'         ← Fixed (digits only)
  customer.ltv      → 225.75               ← After fix
  customer.segment  → 'new'                ← Should be 'regular'!

Found second bug—LTV of 225 should put customer in 'new' segment, but threshold might be wrong.

Check Segment Logic

>>> calculate_ltv(record)
225.75

>>> determine_segment(record)
'new'

# Check threshold
>>> ltv = 225.75
>>> ltv > 500
False
>>> ltv > 100  # Maybe threshold should be lower?
True

Complete Fix

def calculate_ltv(record):
    orders = record.get('orders', [])
    return sum(o.get('total') or 0 for o in orders)  # ← Handle None

def determine_segment(record):
    ltv = calculate_ltv(record)
    if ltv > 1000:
        return 'vip'
    elif ltv > 200:  # ← Adjusted threshold
        return 'regular'
    return 'new'

Total debugging time: 5 minutes using Variables panel, Watch, and Debug Console.

Without debugger: Adding print statements, processing thousands of records, analyzing output logs—easily 30+ minutes.

Advanced Data Inspection Techniques

Inspecting Large Collections

def process_large_dataset(records):
    # records has 10,000 items
    filtered = [r for r in records if r['active']]  # ← Breakpoint

Debug console:

>>> len(records)
10000

# Don't expand all 10k in Variables panel!
# Use debug console:

>>> records[0]
{'id': 1, 'active': True, 'name': 'Item 1'}

>>> records[:5]  # First 5
[...]

>>> sum(1 for r in records if r['active'])
6234

>>> from collections import Counter
>>> Counter(r['category'] for r in records)
Counter({'electronics': 3456, 'clothing': 2891, ...})

Inspecting Class Instances

class User:
    def __init__(self, id, name, email):
        self.id = id
        self.name = name
        self.email = email
        self._cache = {}
    
    def get_orders(self):
        return self._cache.get('orders', [])

user = User(123, 'Alice', '[email protected]')  # ← Breakpoint

Variables panel shows:

VARIABLES
  ▼ user: User
    id: 123
    name: "Alice"
    email: "[email protected]"
    ▼ _cache: {}

Debug console:

>>> user.id
123

>>> dir(user)  # See all attributes and methods
['_cache', 'email', 'get_orders', 'id', 'name', ...]

>>> vars(user)  # Instance __dict__
{'id': 123, 'name': 'Alice', 'email': '[email protected]', '_cache': {}}

>>> hasattr(user, 'get_orders')
True

>>> callable(user.get_orders)
True

Working with JSON Data

import json

def load_config(path):
    with open(path) as f:
        config = json.load(f)  # ← Breakpoint
    return config

Debug console:

>>> json.dumps(config, indent=2)  # Pretty print
{
  "api_key": "...",
  "endpoints": {
    "users": "/api/v1/users",
    "orders": "/api/v1/orders"
  }
}

>>> list(config.keys())
['api_key', 'endpoints', 'timeout', 'retry_count']

>>> config.get('retry_count', 3)
5

Checking Types and Truthiness

def validate_input(data):
    # Is data valid?
    result = process_data(data)  # ← Breakpoint

Debug console:

>>> data
''

>>> bool(data)
False  # Empty string is falsy!

>>> type(data)
<class 'str'>

>>> isinstance(data, str)
True

>>> data == ''
True

>>> len(data)
0

Best Practices

1. Use Watch for Calculated Values

Instead of adding print statements for calculations, use watch expressions:

# Watch expressions:
total = subtotal + tax
discount_amount = subtotal * discount_rate
final_price = total - discount_amount

2. Navigate Call Stack for Context

When you hit a breakpoint deep in code, click up the call stack to see:

• What arguments were passed

• Where the function was called from

• Parent function's state

3. Test in Debug Console, Then Update Code

Always test your fix in debug console before modifying code:

# Test fix first:
>>> new_value = calculate_fix()
>>> verify_fix(new_value)
True  # ← Works! Now update code

4. Copy Expression for Documentation

When you figure out a complex expression in debug console, copy it for code comments or documentation:

# Found via debug console:
active_premium_users = [u for u in users if u['active'] and u['tier'] == 'premium']

5. Use Variables Filter for Large Scopes

When debugging functions with many variables, filter the Variables panel instead of scrolling.

Common Patterns

Pattern 1: Inspect Before Exception

try:
    result = risky_operation(data)  # ← Breakpoint before exception
except Exception as e:
    handle_error(e)

Inspect data to see what causes the exception.

Pattern 2: Watch Accumulator Variables

total = 0
for item in items:  # ← Breakpoint
    total += item.amount
# Watch: total

See total update with each iteration.

Pattern 3: Verify API Responses

response = requests.get(url)  # ← Breakpoint after API call
data = response.json()

Debug console:

>>> response.status_code
200
>>> response.headers
{...}
>>> data.keys()
dict_keys(['results', 'count'])

What's Next

You now master:

• Variables panel for inspecting all scopes

• Watch expressions for monitoring calculations

• Call stack navigation for understanding context

• Debug console REPL for testing and exploration

In Part 4: Advanced Debugging Techniques, you'll learn debugging async/await code, exception handling strategies, debugging multi-threaded applications, and using logpoints effectively.

---

Based on inspecting thousands of variables and debugging complex data pipelines in production Python applications.