Debugging Programs with Print Statements

Two Ways to Keep Input

Debugging becomes easier when you can see how a program's data changes. Consider a program that reads numbers and computes an average. One approach keeps only a running total and a count. Another stores every number in a list. Both can produce the same average, but they preserve different information. The running-total approach is compact and uses less memory. The list approach keeps the original data, which is valuable when you need further analysis or want to inspect what the program actually received.

Tracing Both Methods

The two approaches agree on the final average, but their intermediate state is different. After processing 10, 20, and 30, the running-total method retains total equal to 60 and count equal to 3. The list method retains [10, 20, 30]. The list gives you more evidence about what happened during the loop: you can inspect each original value instead of seeing only the combined result.

Averages from Collected Data

Finding the Failing State

A traceback identifies where a program stopped, but it may not show which input caused the failure. A print statement placed immediately before the failing line can reveal the variable's exact state at that moment. A prefix such as “Debug:” separates diagnostic output from the program's regular output.

for line in lines: words = line.split() print("Debug:", words) if words[0] == "From": print(words[2])

Blank Lines and Empty Lists

When a file contains a blank line, splitting that line produces an empty list. An empty list has no element at index 0. Therefore, code that evaluates words[0] fails with IndexError: list index out of range. The important debugging insight is that the error is not caused by the split operation itself. The failure occurs because the program assumes that the result of split() always contains at least one word.

Debug: ['From', 'person@example.com', 'Monday']
Monday
Debug: []
IndexError: list index out of range

Guarding Before Access

The guardian pattern checks that data is valid before the program uses it. For a list produced by splitting a line, the guard can check whether len(words) is greater than zero. Only non-empty lists continue to the code that accesses words[0]. Empty lists are skipped, so the protected access cannot produce an IndexError from that condition.

for line in lines: words = line.split() print("Debug:", words) if len(words) > 0: if words[0] == "From": print(words[2])

Common Debugging Mistakes

• Keeping only a running total when later analysis is required

  The individual numbers were not stored, so the original data is no longer available through that method.

  Fix: Store the values in a list when you need multiple statistics, comparisons, or direct inspection of the input.

• Assuming every parsed line contains a word at index 0

  A blank line produces an empty list, which has no index 0.

  Fix: Check that the parsed list is non-empty before accessing an index.

• Printing a variable too far away from the failure

  The displayed state may no longer describe the input that caused the crash.

  Fix: Add a Debug: print immediately before the failing operation.

• Treating the traceback as a complete explanation

  The traceback identifies the failure location, but the unexpected input explains why the assumption failed.

  Fix: Inspect the relevant variable, identify the malformed or empty input, and then add an appropriate guard.

Practice the Trace

Debugging Checklist

1. Decide whether you need only a final result or need to preserve the original values.
2. Use total and count for a simple running average when the data will not be needed later.
3. Use a list when you need further analysis, comparisons, or a clear view of the collected input.
4. Use sum() for the list total and len() for the number of list elements.
5. When a failure occurs, print the relevant variable immediately before the failing line.
6. If the debug output shows an empty or malformed value, compare the program's assumption with the actual input.
7. Add a guardian condition so invalid or empty data is not used as though it were valid.