As you have learned, adjusting medication dosages for patients with renal impairment is a crucial aspect of pharmacy practice. This ensures safety and effectiveness, as reduced kidney function can affect how drugs are processed in the body. You previously explored how to represent patient and medication data using Python dictionaries and lists, and how to perform calculations such as multiplying a standard dose by a renal adjustment factor.

When handling multiple patients, you often need to iterate through a list of patient data, apply calculations to each entry, and summarize or report key findings. This challenge will reinforce your ability to process lists of dictionaries, perform calculations for each item, and identify important results, such as the patient with the lowest adjusted dose.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_returns_correct_adjusted_list(self):
        import user_code
        importlib.reload(user_code)
        patients_data = [
            {'name': 'Alice', 'standard_dose': 100, 'renal_factor': 0.6},
            {'name': 'Bob', 'standard_dose': 80, 'renal_factor': 0.8},
            {'name': 'Carlos', 'standard_dose': 120, 'renal_factor': 0.5}
        ]
        expected = [
            {'name': 'Alice', 'adjusted_dose': 60.0},
            {'name': 'Bob', 'adjusted_dose': 64.0},
            {'name': 'Carlos', 'adjusted_dose': 60.0}
        ]
        result = user_code.adjust_renal_doses(patients_data)
        _dynamic_test(
            self,
            isinstance(result, list) and all(isinstance(x, dict) for x in result),
            "Returned a list of dictionaries.",
            f"Expected a list of dictionaries, got: {result}"
        )
        for i in range(len(expected)):
            _dynamic_test(
                self,
                result[i]['name'] == expected[i]['name'] and abs(result[i]['adjusted_dose'] - expected[i]['adjusted_dose']) < 1e-6,
                f"Correct adjusted dose for {expected[i]['name']}.",
                f"Expected {expected[i]}, got {result[i]}"
            )

    def test_adjusted_dose_calculation(self):
        import user_code
        importlib.reload(user_code)
        patients_data = [
            {'name': 'Diana', 'standard_dose': 90, 'renal_factor': 0.7},
            {'name': 'Eli', 'standard_dose': 60, 'renal_factor': 0.5}
        ]
        result = user_code.adjust_renal_doses(patients_data)
        expected = [
            {'name': 'Diana', 'adjusted_dose': 63.0},
            {'name': 'Eli', 'adjusted_dose': 30.0}
        ]
        for i in range(len(expected)):
            _dynamic_test(
                self,
                result[i]['name'] == expected[i]['name'] and abs(result[i]['adjusted_dose'] - expected[i]['adjusted_dose']) < 1e-6,
                f"Adjusted dose for {expected[i]['name']} is correct.",
                f"Expected {expected[i]}, got {result[i]}"
            )

    def test_prints_lowest_adjusted_dose(self):
        import user_code
        importlib.reload(user_code)
        patients_data = [
            {'name': 'Frank', 'standard_dose': 100, 'renal_factor': 0.4},
            {'name': 'Grace', 'standard_dose': 90, 'renal_factor': 0.5},
            {'name': 'Helen', 'standard_dose': 80, 'renal_factor': 0.6}
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.adjust_renal_doses(patients_data)
        output = normalize_text(f.getvalue())
        expected_line = normalize_text("Patient with lowest adjusted dose: Frank (40.0)")
        _dynamic_test(
            self,
            expected_line in output,
            "Correctly prints the patient with the lowest adjusted dose.",
            f"Expected print: '{expected_line}' not found in output: {output}"
        )

    def test_handles_single_patient(self):
        import user_code
        importlib.reload(user_code)
        patients_data = [
            {'name': 'Isabel', 'standard_dose': 200, 'renal_factor': 0.75}
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            result = user_code.adjust_renal_doses(patients_data)
        expected = [{'name': 'Isabel', 'adjusted_dose': 150.0}]
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == 1 and result[0]['name'] == 'Isabel' and abs(result[0]['adjusted_dose'] - 150.0) < 1e-6,
            "Handles single patient correctly.",
            f"Expected {expected}, got {result}"
        )
        output = normalize_text(f.getvalue())
        expected_line = normalize_text("Patient with lowest adjusted dose: Isabel (150.0)")
        _dynamic_test(
            self,
            expected_line in output,
            "Correctly prints the single patient as lowest adjusted dose.",
            f"Expected print: '{expected_line}' not found in output: {output}"
        )

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 pharmacists, focusing on real-world pharmaceutical data analysis, medication management, and healthcare problem-solving using Python. Designed for learners with basic Python knowledge, this course bridges pharmacy and programming through engaging theory and hands-on challenges.

Learn how to represent, manipulate, and analyze pharmaceutical data using Python and pandas. This section introduces core data structures and techniques for handling medication and patient information.

Apply Python to calculate medication dosages, check for drug interactions, and support safe patient care. This section focuses on mathematical operations and logic relevant to pharmacy practice.

Use Python to analyze and visualize clinical data relevant to pharmacy, such as lab results, adverse event rates, and medication adherence. This section emphasizes data-driven decision making.

Challenge: Renal Dose Adjustment Tool

Oplossing

Challenge: Renal Dose Adjustment Tool

Oplossing