As a pharmacist, you often need to assess how well patients are following their medication regimens. In clinical practice, **medication adherence** is typically measured as the percentage of prescribed doses that a patient actually takes. Using pandas, you can efficiently calculate and report adherence rates for groups of patients. This allows you to quickly identify those who may need additional support or intervention. By calculating adherence percentages, filtering out patients with low adherence, and summarizing the overall adherence in your population, you gain actionable insights that can improve patient outcomes and support pharmacy quality initiatives.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout
import pandas as pd

class TestTask(unittest.TestCase):
    def setUp(self):
        self.user_code = importlib.import_module("user_code")
        self.df = pd.DataFrame({
            "patient": ["Alice", "Bob", "Charlie", "Diana"],
            "total_prescribed": [30, 30, 30, 30],
            "doses_taken": [28, 20, 22, 30]
        })

    def test_adherence_column_calculated(self):
        importlib.reload(self.user_code)
        df_copy = self.df.copy()
        # Run function
        self.user_code.medication_adherence_report(df_copy)
        adherence = df_copy.get("adherence", None)
        _dynamic_test(
            self,
            (adherence is not None and all(isinstance(x, float) or isinstance(x, int) for x in adherence)),
            "Adherence column is correctly added to DataFrame.",
            "Adherence column missing or not numeric in DataFrame after function call."
        )
        # Check correct values
        expected = [28/30*100, 20/30*100, 22/30*100, 30/30*100]
        for i, val in enumerate(expected):
            _dynamic_test(
                self,
                abs(adherence.iloc[i] - val) < 0.01,
                f"Adherence value for patient {df_copy['patient'][i]} is correct.",
                f"Expected {val} for {df_copy['patient'][i]}, got {adherence.iloc[i]}."
            )

    def test_low_adherence_printed(self):
        importlib.reload(self.user_code)
        df_copy = self.df.copy()
        f = io.StringIO()
        with redirect_stdout(f):
            self.user_code.medication_adherence_report(df_copy)
        output = normalize_text(f.getvalue())
        expected_names = ["bob", "charlie"]
        for name in expected_names:
            _dynamic_test(
                self,
                name in output,
                f"Patient '{name.title()}' with low adherence is printed.",
                f"Patient '{name.title()}' with adherence <75% is not printed."
            )
        # Ensure no extra names printed
        for name in ["alice", "diana"]:
            _dynamic_test(
                self,
                name not in output,
                f"Patient '{name.title()}' with >=75% adherence is not printed.",
                f"Patient '{name.title()}' with high adherence should not be printed."
            )

    def test_average_adherence_printed(self):
        importlib.reload(self.user_code)
        df_copy = self.df.copy()
        f = io.StringIO()
        with redirect_stdout(f):
            self.user_code.medication_adherence_report(df_copy)
        output = normalize_text(f.getvalue())
        # The average adherence for this data is:
        vals = [28/30*100, 20/30*100, 22/30*100, 30/30*100]
        expected_avg = sum(vals)/len(vals)
        # Check if average number appears in output (rounded to 2 decimals)
        found = False
        for fmt in ["{:.2f}", "{:.1f}", "{:.0f}", "{}"]:
            if fmt.format(expected_avg) in output or fmt.format(round(expected_avg,2)) in output:
                found = True
                break
        _dynamic_test(
            self,
            found,
            "Average adherence is correctly printed.",
            f"Average adherence {expected_avg} 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: Medication Adherence Report

解答