Automated expenditure summaries play a crucial role in supporting **budget oversight** for government agencies. By systematically compiling and aggregating spending data, you can quickly identify departmental spending patterns, ensure that expenditures align with budgetary constraints, and provide timely information for audits or policy decisions. Automating this process reduces manual errors and frees up valuable analyst time for higher-level tasks.

# Example dataset: Each dictionary represents a monthly expenditure record.
monthly_expenditures = [
    {"department": "Health", "month": "January", "amount": 12000},
    {"department": "Transport", "month": "January", "amount": 8000},
    {"department": "Education", "month": "January", "amount": 15000},
    {"department": "Health", "month": "February", "amount": 11000},
    {"department": "Transport", "month": "February", "amount": 8500},
    {"department": "Education", "month": "February", "amount": 14500},
    {"department": "Health", "month": "March", "amount": 13000},
    {"department": "Transport", "month": "March", "amount": 9000},
    {"department": "Education", "month": "March", "amount": 14800},
    # ... additional months for each department
]

To create a summary of total annual expenditure by department, you need to aggregate values across all months for each department. This involves iterating through the dataset, grouping amounts by the `department` field, and summing the expenditures for each group. Such aggregation is foundational for producing clear, actionable reports that inform funding decisions and resource allocation.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_returns_dict_with_departments(self):
        import user_code
        importlib.reload(user_code)
        records = [
            {"department": "Health", "month": "January", "amount": 1000},
            {"department": "Education", "month": "February", "amount": 2000},
            {"department": "Transport", "month": "March", "amount": 3000},
        ]
        result = user_code.summarize_expenditures(records)
        _dynamic_test(
            self,
            isinstance(result, dict) and set(result.keys()) == {"Health", "Education", "Transport"},
            "Returns a dictionary with each department as a key",
            f"Expected departments: Health, Education, Transport. Got: {result}"
        )

    def test_sums_amounts_across_records(self):
        import user_code
        importlib.reload(user_code)
        records = [
            {"department": "Health", "month": "January", "amount": 1200},
            {"department": "Health", "month": "February", "amount": 1300},
            {"department": "Health", "month": "March", "amount": 1500},
            {"department": "Transport", "month": "January", "amount": 900},
            {"department": "Transport", "month": "February", "amount": 1100},
        ]
        result = user_code.summarize_expenditures(records)
        _dynamic_test(
            self,
            isinstance(result, dict) and result.get("Health", -1) == 4000 and result.get("Transport", -1) == 2000,
            "Sums all amounts for a department across multiple records",
            f"Expected Health: 4000, Transport: 2000, got: {result}"
        )

    def test_handles_single_record_department(self):
        import user_code
        importlib.reload(user_code)
        records = [
            {"department": "Parks", "month": "May", "amount": 7000},
        ]
        result = user_code.summarize_expenditures(records)
        _dynamic_test(
            self,
            isinstance(result, dict) and result.get("Parks", -1) == 7000 and len(result) == 1,
            "Handles departments with only one record",
            f"Expected Parks: 7000, got: {result}"
        )

    def test_handles_empty_input(self):
        import user_code
        importlib.reload(user_code)
        records = []
        result = user_code.summarize_expenditures(records)
        _dynamic_test(
            self,
            isinstance(result, dict) and len(result) == 0,
            "Handles an empty input list by returning an empty dictionary",
            f"Expected empty dictionary, got: {result}"
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

A practical Python course tailored for government analysts, focusing on data analysis, visualization, and decision-making using real-world scenarios relevant to public sector work. Learn to harness Python's power to extract insights, visualize trends, and support evidence-based policy.

Explore how Python can be used to analyze government datasets, extract actionable insights, and support evidence-based policy decisions.

Apply statistical methods to government datasets to evaluate policies, measure impact, and support data-driven decisions.

Discover how Python can automate repetitive analytical tasks, streamline reporting, and improve efficiency in government operations.

Challenge: Automate Monthly Expenditure Summaries

Lösung