Proportional allocation is a fundamental principle in government budgeting, ensuring that resources are distributed fairly based on criteria such as **population size**, need, or performance. In public sector finance, this method helps guarantee that regions with larger populations receive a greater share of the budget, reflecting their greater demand for services. By applying **proportional allocation**, you can support evidence-based decision-making and uphold equity in resource distribution.

regions = [
    {"name": "North District", "population": 120000},
    {"name": "South District", "population": 80000},
    {"name": "East District", "population": 100000},
    {"name": "West District", "population": 60000}
]

total_budget = 1000000  # Total budget to be allocated

To allocate the total budget proportionally, calculate each region's share using the formula:

`region_budget = (region_population / total_population) * total_budget`

First, sum the populations of all regions to get the total population. Then, for each region, divide its population by the total population to find its proportion, and multiply this by the total budget. This ensures that each region's allocation reflects its population size. After calculating allocations, verify that the sum of all regional budgets equals the total budget. If necessary, you can adjust the final allocation (such as the last region) to correct minor rounding errors, ensuring the total matches exactly.


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

class TestTask(unittest.TestCase):
    def test_returns_list_of_dicts(self):
        import user_code
        importlib.reload(user_code)
        regions = [
            {"name": "North District", "population": 120000},
            {"name": "South District", "population": 80000},
            {"name": "East District", "population": 100000},
            {"name": "West District", "population": 60000}
        ]
        total_budget = 1000000
        result = user_code.allocate_budget_by_population(regions, total_budget)
        _dynamic_test(
            self,
            isinstance(result, list) and all(isinstance(x, dict) for x in result),
            "Function returns a list of dictionaries.",
            f"Expected list of dicts, got: {result}",
        )
        for r in result:
            _dynamic_test(
                self,
                "name" in r and "allocated_budget" in r,
                "Each dict contains 'name' and 'allocated_budget'.",
                f"Missing keys in: {r}",
            )

    def test_sum_of_allocations_equals_total_budget(self):
        import user_code
        importlib.reload(user_code)
        regions = [
            {"name": "North District", "population": 120000},
            {"name": "South District", "population": 80000},
            {"name": "East District", "population": 100000},
            {"name": "West District", "population": 60000}
        ]
        total_budget = 1000000
        result = user_code.allocate_budget_by_population(regions, total_budget)
        total_allocated = sum(r["allocated_budget"] for r in result)
        _dynamic_test(
            self,
            total_allocated == total_budget,
            "Sum of allocations equals total budget.",
            f"Expected sum {total_budget}, got {total_allocated}",
        )

    def test_proportionality(self):
        import user_code
        importlib.reload(user_code)
        regions = [
            {"name": "One", "population": 10},
            {"name": "Two", "population": 30}
        ]
        total_budget = 400
        result = user_code.allocate_budget_by_population(regions, total_budget)
        d = {r["name"]: r["allocated_budget"] for r in result}
        expected_one = round((10/40)*400)
        expected_two = 400 - expected_one
        _dynamic_test(
            self,
            d["One"] == expected_one and d["Two"] == expected_two,
            "Allocations are proportional to population.",
            f"Expected {{'One': {expected_one}, 'Two': {expected_two}}}, got: {d}",
        )

    def test_rounding_correction(self):
        import user_code
        importlib.reload(user_code)
        regions = [
            {"name": "Alpha", "population": 1},
            {"name": "Beta", "population": 1},
            {"name": "Gamma", "population": 1}
        ]
        total_budget = 100
        result = user_code.allocate_budget_by_population(regions, total_budget)
        total_allocated = sum(r["allocated_budget"] for r in result)
        _dynamic_test(
            self,
            total_allocated == total_budget,
            "Handles rounding so total matches total_budget.",
            f"Expected sum {total_budget}, got {total_allocated}",
        )

    def test_handles_any_number_of_regions(self):
        import user_code
        importlib.reload(user_code)
        regions = [
            {"name": f"Region {i}", "population": 10*(i+1)} for i in range(7)
        ]
        total_budget = 7000
        result = user_code.allocate_budget_by_population(regions, total_budget)
        total_allocated = sum(r["allocated_budget"] for r in result)
        _dynamic_test(
            self,
            total_allocated == total_budget,
            "Function works for any number of regions.",
            f"Expected sum {total_budget}, got {total_allocated}",
        )

    def test_handles_large_budget(self):
        import user_code
        importlib.reload(user_code)
        regions = [
            {"name": "X", "population": 500},
            {"name": "Y", "population": 500}
        ]
        total_budget = 10**9
        result = user_code.allocate_budget_by_population(regions, total_budget)
        total_allocated = sum(r["allocated_budget"] for r in result)
        _dynamic_test(
            self,
            total_allocated == total_budget,
            "Handles large total budget.",
            f"Expected sum {total_budget}, got {total_allocated}",
        )

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: Calculate Regional Budget Allocations

解答