In pharmacy practice, it is common to analyze prescription records to identify which medications are most frequently prescribed. Using pandas, you can group data by drug name and count the number of prescriptions for each medication, allowing you to quickly spot trends or high-demand drugs. By sorting these results, you can easily determine which drug tops the prescription list. This kind of data analysis is essential for inventory planning, formulary management, and understanding patient care patterns.


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.df = pd.DataFrame({
            'Patient': ['Alice', 'Bob', 'Alice', 'Derek', 'Bob', 'Eve', 'Frank', 'Alice', 'Eve', 'Derek'],
            'Drug': ['Atorvastatin', 'Metformin', 'Atorvastatin', 'Lisinopril', 'Metformin', 'Atorvastatin', 'Lisinopril', 'Metformin', 'Atorvastatin', 'Metformin'],
            'Date': ['2024-04-01', '2024-04-01', '2024-04-15', '2024-04-16', '2024-04-17', '2024-04-18', '2024-04-19', '2024-04-20', '2024-04-21', '2024-04-22']
        })
        self.expected_summary = pd.DataFrame({
            'Drug': ['Atorvastatin', 'Metformin', 'Lisinopril'],
            'Prescription_Count': [4, 4, 2]
        })

    def _get_function(self):
        import user_code
        importlib.reload(user_code)
        return getattr(user_code, 'analyze_prescription_frequency', None)

    def test_grouping_and_counting(self):
        func = self._get_function()
        _dynamic_test(
            self,
            func is not None,
            "Function 'analyze_prescription_frequency' exists.",
            "Function 'analyze_prescription_frequency' is not defined."
        )
        f = io.StringIO()
        with redirect_stdout(f):
            func(self.df)
        output = f.getvalue()
        # Check that all drugs and correct counts are present in output
        for idx, row in self.expected_summary.iterrows():
            drug = row['Drug']
            count = row['Prescription_Count']
            out_line = f"{drug}"
            _dynamic_test(
                self,
                drug in output,
                f"Drug '{drug}' present in output.",
                f"Drug '{drug}' missing from output: {output}"
            )
            _dynamic_test(
                self,
                str(count) in output,
                f"Count '{count}' present in output.",
                f"Count '{count}' missing from output: {output}"
            )

    def test_sorted_descending(self):
        func = self._get_function()
        f = io.StringIO()
        with redirect_stdout(f):
            func(self.df)
        output = f.getvalue()
        # Check that Atorvastatin and Metformin are at the top (both 4), then Lisinopril (2)
        # Find the summary table in the output
        # We will check the order of lines for the summary table
        summary_start = output.find('Prescription summary (sorted):')
        _dynamic_test(
            self,
            summary_start != -1,
            "Summary table header present in output.",
            "Summary table header missing from output."
        )
        summary_lines = output[summary_start:].splitlines()
        # The summary table will be printed as a DataFrame, so first line after header is column names
        # We expect Atorvastatin and Metformin to appear before Lisinopril
        summary_str = '\\n'.join(summary_lines)
        ator_index = summary_str.find('Atorvastatin')
        metf_index = summary_str.find('Metformin')
        lisi_index = summary_str.find('Lisinopril')
        # Both Atorvastatin and Metformin should appear before Lisinopril
        _dynamic_test(
            self,
            (ator_index != -1 and metf_index != -1 and lisi_index != -1) and (lisi_index > ator_index or lisi_index > metf_index),
            "Summary table is sorted with Atorvastatin and Metformin above Lisinopril.",
            f"Summary table sorting incorrect. Output: {summary_str}"
        )

    def test_top_drug_printed(self):
        func = self._get_function()
        f = io.StringIO()
        with redirect_stdout(f):
            func(self.df)
        output = f.getvalue()
        # Both Atorvastatin and Metformin have 4 prescriptions, so either may be printed as top drug
        top_line = [line for line in output.splitlines() if 'Drug with the highest number of prescriptions' in line]
        _dynamic_test(
            self,
            len(top_line) == 1,
            "Top drug line printed exactly once.",
            f"Top drug line not printed or printed multiple times. Output: {output}"
        )
        found = any(drug in top_line[0] for drug in ['Atorvastatin', 'Metformin'])
        _dynamic_test(
            self,
            found,
            "Top drug is either Atorvastatin or Metformin.",
            f"Top drug line does not contain expected drug: {top_line[0]}"
        )

    def test_summary_table_printed(self):
        func = self._get_function()
        f = io.StringIO()
        with redirect_stdout(f):
            func(self.df)
        output = f.getvalue()
        # Check summary header and that DataFrame is printed
        _dynamic_test(
            self,
            'Prescription summary (sorted):' in output,
            "Summary header printed.",
            "Summary header not printed."
        )
        # Check that the DataFrame printout has both columns
        _dynamic_test(
            self,
            'Drug' in output and 'Prescription_Count' in output,
            "Summary table columns printed.",
            f"Summary table columns missing. 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: Prescription Frequency Analysis

解答