CLI Expense Tracker with File I/O

What you will learn

• Process delimited text records using Python's standard csv.DictReader
• Accumulate and categorize continuous numerical data in Python dictionaries
• Format clean console outputs displaying subtotals and percentage contributions
• Handle string-to-float data parsing with robust fallback defaults

What you need first

totals = {}; totals["food"] = totals.get("food", 0.0) + 150.0; print(totals)

{'food': 150.0}

import csv, io; r = list(csv.DictReader(io.StringIO("cat,amt\nTaxi,45.0\n"))); print(r[0]["cat"])

Taxi

total = 200.0; sub = 50.0; pct = round(sub * 100 / total, 1) if total > 0 else 0.0; print(pct)

25.0

Architecture and data flow

The data

A multi-line CSV string containing transaction date, category, amount, and descriptive note.

Step by step

Read each step, run its code, then check your output against the one shown.

1. 01

   Initialize in-memory raw expense ledger

   We begin by establishing a deterministic sample string representing raw CSV text received from field agents. In production pipelines, files arrive from local filesystem directories or remote cloud object storage, but buffering through standard strings allows rapid unit testing without external storage dependencies. We inspect the raw lines, isolate the header row, and verify that the line count corresponds to expected records. This inspection guarantees that subsequent parsing logic receives valid delimited text without unhandled null bytes or completely empty payloads before deeper analytical logic runs.

   PythonStep 1Copy

   data = """date,category,amount,note
   2024-03-01,Groceries,450.0,Weekly vegetable market
   2024-03-01,Transport,120.0,Metro smart card recharge
   2024-03-02,Groceries,350.0,Dairy and provisions
   2024-03-02,Utilities,1200.0,Electricity bill
   2024-03-03,Dining,650.0,Team dinner
   """
   
   lines = [line.strip() for line in data.strip().split("\n") if line.strip()]
   print(f"Header: {lines[0]} | Total rows: {len(lines) - 1}")

   Show outputGuess what it prints first

   Header: date,category,amount,note | Total rows: 5

   Common mistake

   Watch out: Splitting on raw newline without stripping leading or trailing whitespace creates ghost empty rows that corrupt row indexing.

   How you will know

   The output confirms exactly 5 data rows following the header definition.

2. 02

   Expose flaws of naive comma splitting

   Wrong turn first: this step shows the mistake before the fix

   Many junior developers instinctively parse delimited records by splitting strings with line.split(','). Here we deliberately demonstrate why this naive technique fails when real-world notes contain embedded punctuation, such as commas separating descriptions. When a note contains a comma, simple splitting breaks the row into five tokens instead of four, misaligning column indices and causing string fragments to shift into numeric amount positions. Understanding this failure proves why a dedicated RFC-4180 compliant CSV parsing module is mandatory for enterprise pipelines handling untrusted user input.

   PythonStep 2Copy

   naive_row = "2024-03-01,Groceries,450.0,Weekly market, vegetables"
   tokens = naive_row.split(",")
   print(f"Naive split column count: {len(tokens)} | Expected: 4 | Columns: {tokens}")

   Show outputGuess what it prints first

   Naive split column count: 5 | Expected: 4 | Columns: ['2024-03-01', 'Groceries', '450.0', 'Weekly market', ' vegetables']

   Common mistake

   Watch out: Using str.split(',') fails whenever user comments, item names, or formatted descriptions contain embedded commas.

   How you will know

   The naive approach reports 5 columns instead of the expected 4 schema fields.

3. 03

   Parse CSV stream with DictReader

   To safely handle quotation, escaped commas, and header mapping, we import Python's standard csv module and wrap our raw string in io.StringIO. The csv.DictReader class reads the first line as field names and yields each subsequent record as a clean dictionary. This abstraction allows accessing values by column name rather than brittle numerical indices. We verify that all five rows parse cleanly, check the data types, and inspect the first record to ensure that category and amount fields match expected schema keys without index alignment bugs.

   PythonStep 3Copy

   import csv, io
   
   data = """date,category,amount,note
   2024-03-01,Groceries,450.0,Weekly vegetable market
   2024-03-01,Transport,120.0,Metro smart card recharge
   2024-03-02,Groceries,350.0,Dairy and provisions
   2024-03-02,Utilities,1200.0,Electricity bill
   2024-03-03,Dining,650.0,Team dinner
   """
   
   reader = list(csv.DictReader(io.StringIO(data.strip())))
   first_cat = reader[0]["category"]
   first_amt = float(reader[0]["amount"])
   print(f"Parsed {len(reader)} rows successfully. First category: {first_cat}, First amount: {first_amt}")

   Show outputGuess what it prints first

   Parsed 5 rows successfully. First category: Groceries, First amount: 450.0

   Common mistake

   Watch out: Forgetting to cast row['amount'] from str to float leads to string concatenation rather than numeric addition.

   How you will know

   The parsed row list contains 5 records with correct categorical and numeric bindings.

4. 04

   Accumulate categorical subtotals and grand total

   With clean dictionary records available, we iterate across each transaction to accumulate department spending. We maintain a running grand total float and a categorical accumulator dictionary. To prevent KeyError exceptions when encountering a new category for the first time, we utilize the dict.get(key, 0.0) method, which supplies a zero float fallback. We cast each amount to a float and add it to both the category subtotal and the cumulative total, validating that all expenditures are properly accounted for across departmental cost centers.

   PythonStep 4Copy

   import csv, io
   
   data = """date,category,amount,note
   2024-03-01,Groceries,450.0,Weekly vegetable market
   2024-03-01,Transport,120.0,Metro smart card recharge
   2024-03-02,Groceries,350.0,Dairy and provisions
   2024-03-02,Utilities,1200.0,Electricity bill
   2024-03-03,Dining,650.0,Team dinner
   """
   
   reader = list(csv.DictReader(io.StringIO(data.strip())))
   by_category = {}
   total = 0.0
   
   for row in reader:
       amt = float(row["amount"])
       cat = row["category"]
       by_category[cat] = by_category.get(cat, 0.0) + amt
       total += amt
   
   print(f"Processed {len(reader)} receipts. Total: {total} across {len(by_category)} categories.")

   Show outputGuess what it prints first

   Processed 5 receipts. Total: 2770.0 across 4 categories.

   Common mistake

   Watch out: Initializing categories without float defaults can introduce floating point precision drift if values are rounded prematurely.

   How you will know

   Total expenditure reaches 2770.0 across exactly 4 distinct expense categories.

5. 05

   Format executive breakdown report with percentages

   The final operational milestone formats the raw mathematical subtotals into an executive summary report suitable for management review. We sort the category keys alphabetically to ensure deterministic display order across runs. For each category, we compute its percentage share relative to overall expenditure, rounding the result to one decimal place for clarity. We include a defensive guard to ensure that an empty ledger with zero total expenditure outputs zero percentages rather than terminating with an unhandled ZeroDivisionError in production environments.

   PythonStep 5Copy

   import csv, io
   
   data = """date,category,amount,note
   2024-03-01,Groceries,450.0,Weekly vegetable market
   2024-03-01,Transport,120.0,Metro smart card recharge
   2024-03-02,Groceries,350.0,Dairy and provisions
   2024-03-02,Utilities,1200.0,Electricity bill
   2024-03-03,Dining,650.0,Team dinner
   """
   
   reader = list(csv.DictReader(io.StringIO(data.strip())))
   by_category = {}
   total = 0.0
   
   for row in reader:
       amt = float(row["amount"])
       cat = row["category"]
       by_category[cat] = by_category.get(cat, 0.0) + amt
       total += amt
   
   print(f"Total Expenditure: {total}")
   for c, a in sorted(by_category.items()):
       pct = round(a * 100 / total, 1) if total > 0 else 0.0
       print(f"  {c}: {a} ({pct}%)")

   Show outputGuess what it prints first

   Total Expenditure: 2770.0
     Dining: 650.0 (23.5%)
     Groceries: 800.0 (28.9%)
     Transport: 120.0 (4.3%)
     Utilities: 1200.0 (43.3%)

   Common mistake

   Watch out: Calculating percentage without rounding produces floating-point artifacts like 28.88086642599278% that clutter executive reports.

   How you will know

   All four categories display sorted subtotals and rounded percentage shares matching total spend.

Build it yourself

Write your solution below, run it in your browser, and pass every check.

What the result means

Interpretation

The breakdown reveals that Utilities and Groceries represent over 72% of all submitted operational expenditures, while Transport accounted for less than 5%. In a production environment, this distribution highlights where operational cost caps should be enforced and verifies that all employee reimbursements match authorized departmental budgets before bank payouts are initiated.

The message you would send

Hi Finance Team, the automated expense reconciliation parser has processed the monthly field sales receipts batch. Total expenditure stands at 2,770.0 across 4 categories, with Utilities (43.3%) and Groceries (28.9%) driving the majority of reimbursements. The summary table and audit breakdown are attached for disbursement sign-off.

Put it on your CV

Resume or LinkedIn bullet

Engineered a zero-dependency CLI expense reconciliation engine in Python using standard csv stream parsing, reducing reimbursement turnaround from three days to four minutes.

README for GitHub

# CLI Expense Tracker with Stream I/O

## Business Context
Manual reconciliation of monthly sales expense receipts delayed employee reimbursements by up to two weeks and introduced frequent spreadsheet summation errors.

## Solution Architecture
- Ingested multi-line CSV streams using Python's standard `csv.DictReader` and `io.StringIO`.
- Accumulated categorical expenditure subtotals with defensive dictionary fallback patterns.
- Generated alphabetically sorted executive breakdown tables with precise percentage allocations.

## Verification
Passes all automated verification checks on Python 3 standard library without external runtime dependencies.

Keep going

• LessonPython File Handling and Stream I/O
• Case studyImmutable Double-Entry Reward Coin Ledger
• Case studyDynamic Rider Payout and Surge Surcharge Calculator