As a pharmacist, ensuring patient safety often involves checking for potential drug interactions. You have already learned how to represent medication data using Python dictionaries, where each key-value pair can represent a specific interaction and its corresponding warning. When given a list of medications, you can systematically check each unique pair to see if an interaction exists. This approach prevents missing any dangerous combinations and helps automate crucial safety checks. By reviewing all possible pairs and referencing a dictionary of interactions, you can quickly identify and communicate any issues or confirm that the medication regimen is safe for the patient.


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 setUp(self):
        self.interaction_dict = {
            ('Aspirin', 'Warfarin'): "Increased risk of bleeding when Aspirin is combined with Warfarin.",
            ('Metformin', 'Contrast Dye'): "Risk of lactic acidosis when Metformin is used with Contrast Dye.",
            ('Amoxicillin', 'Allopurinol'): "Increased risk of rash with Amoxicillin and Allopurinol."
        }

    def test_detects_interaction_and_prints_warning(self):
        import user_code
        importlib.reload(user_code)
        medications = ['Aspirin', 'Warfarin']
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.check_drug_interactions(medications, self.interaction_dict)
        output = normalize_text(f.getvalue())
        expected = normalize_text("Increased risk of bleeding when Aspirin is combined with Warfarin.")
        _dynamic_test(
            self,
            expected in output,
            "Correct warning printed for Aspirin + Warfarin interaction",
            f"Expected warning '{expected}' not found in output: {output}",
        )

    def test_detects_interaction_regardless_of_order(self):
        import user_code
        importlib.reload(user_code)
        medications = ['Warfarin', 'Aspirin']
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.check_drug_interactions(medications, self.interaction_dict)
        output = normalize_text(f.getvalue())
        expected = normalize_text("Increased risk of bleeding when Aspirin is combined with Warfarin.")
        _dynamic_test(
            self,
            expected in output,
            "Function detects interaction regardless of medication order",
            f"Expected warning '{expected}' not found in output: {output}",
        )

    def test_multiple_interactions(self):
        import user_code
        importlib.reload(user_code)
        medications = ['Aspirin', 'Warfarin', 'Metformin', 'Contrast Dye']
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.check_drug_interactions(medications, self.interaction_dict)
        output = normalize_text(f.getvalue())
        expected1 = normalize_text("Increased risk of bleeding when Aspirin is combined with Warfarin.")
        expected2 = normalize_text("Risk of lactic acidosis when Metformin is used with Contrast Dye.")
        _dynamic_test(
            self,
            expected1 in output and expected2 in output,
            "Both warnings printed for multiple interactions",
            f"Expected warnings '{expected1}' and/or '{expected2}' not found in output: {output}",
        )

    def test_no_interaction_prints_safety_message(self):
        import user_code
        importlib.reload(user_code)
        medications = ['Ibuprofen', 'Lisinopril']
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.check_drug_interactions(medications, self.interaction_dict)
        output = normalize_text(f.getvalue())
        expected = normalize_text("No drug interactions detected. Medication list is safe.")
        _dynamic_test(
            self,
            expected in output,
            "Safety message printed when no interactions detected",
            f"Expected safety message not found in output: {output}",
        )

    def test_no_duplicate_warnings(self):
        import user_code
        importlib.reload(user_code)
        medications = ['Aspirin', 'Warfarin', 'Aspirin']
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.check_drug_interactions(medications, self.interaction_dict)
        output = normalize_text(f.getvalue())
        expected = normalize_text("Increased risk of bleeding when Aspirin is combined with Warfarin.")
        # Count occurrences
        count = output.count(expected)
        _dynamic_test(
            self,
            count == 1,
            "Warning printed only once per interaction per run",
            f"Expected warning printed {count} times, should be printed once.",
        )

    def test_function_works_for_any_input(self):
        import user_code
        importlib.reload(user_code)
        # No interactions in dict
        medications = ['A', 'B', 'C']
        empty_dict = {}
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.check_drug_interactions(medications, empty_dict)
        output = normalize_text(f.getvalue())
        expected = normalize_text("No drug interactions detected. Medication list is safe.")
        _dynamic_test(
            self,
            expected in output,
            "Function works for any medication list and interaction dictionary",
            f"Expected safety message not found for empty interaction dict: {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: Drug Interaction Checker

Lösung