Managing pharmaceutical inventory efficiently is vital for pharmacy operations. You have learned how to represent medication data in Python and how to use pandas DataFrames to organize and analyze such information. Using DataFrames makes it easy to filter for specific conditions, such as identifying medications that are low in stock, and to aggregate data, such as calculating total inventory or finding the medication with the highest stock. These skills are essential for pharmacists who must quickly assess inventory to ensure patient care and operational readiness.


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_low_stock_medications(self):
        import user_code
        importlib.reload(user_code)
        df = getattr(user_code, 'df', None)
        _dynamic_test(
            self,
            df is not None,
            "DataFrame 'df' exists.",
            "DataFrame 'df' is not defined."
        )
        # Filter the DataFrame manually
        expected_names = set(['Paracetamol', 'Ibuprofen', 'Metformin'])
        low_stock = df[df['stock'] < 10]
        actual_names = set(low_stock['name'].tolist())
        _dynamic_test(
            self,
            actual_names == expected_names,
            "Correct medications filtered for stock < 10.",
            f"Expected: {expected_names}, got: {actual_names}"
        )

    def test_total_units_variable(self):
        import user_code
        importlib.reload(user_code)
        total_units = getattr(user_code, 'total_units', None)
        _dynamic_test(
            self,
            isinstance(total_units, int),
            "total_units variable is defined as an integer.",
            f"total_units variable is not defined as integer: {total_units}"
        )
        _dynamic_test(
            self,
            total_units == 89,
            "Correct total units in stock.",
            f"Expected total_units to be 89, got {total_units}"
        )

    def test_max_stock_name_dosage(self):
        import user_code
        importlib.reload(user_code)
        med_name_dosage = getattr(user_code, 'med_name_dosage', None)
        _dynamic_test(
            self,
            isinstance(med_name_dosage, str),
            "med_name_dosage variable is defined as string.",
            f"med_name_dosage variable is not defined as string: {med_name_dosage}"
        )
        _dynamic_test(
            self,
            med_name_dosage == 'Cetirizine 10mg',
            "Correct medication with highest stock identified.",
            f"Expected 'Cetirizine 10mg', got '{med_name_dosage}'"
        )

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 Inventory Overview

解答