You have seen how to use pandas to filter and summarize lab results—essential skills for extracting actionable insights from clinical data. Filtering allows you to isolate records that meet specific criteria, such as abnormal values, while aggregation methods help you quickly summarize counts or averages across groups. In real-world pharmacy settings, these techniques enable you to monitor patient safety and flag potential issues promptly.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
import sys
import pandas as pd

class TestTask(unittest.TestCase):
    def test_high_glucose_patients_printed(self):
        import user_code
        importlib.reload(user_code)
        data = {
            'Patient': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
            'Test': ['glucose', 'glucose', 'cholesterol', 'glucose', 'glucose'],
            'Value': [170, 200, 190, 185, 160]
        }
        df = pd.DataFrame(data)
        captured = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = captured
        user_code.lab_result_alert(df)
        sys.stdout = sys_stdout
        output = normalize_text(captured.getvalue())
        _dynamic_test(
            self,
            "bob: 200" in output and "diana: 185" in output,
            "Correct patients with high glucose are printed",
            f"Expected 'Bob: 200' and 'Diana: 185' in output, got: {output}"
        )

    def test_total_high_glucose_count_printed(self):
        import user_code
        importlib.reload(user_code)
        data = {
            'Patient': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
            'Test': ['glucose', 'glucose', 'cholesterol', 'glucose', 'glucose'],
            'Value': [170, 200, 190, 185, 160]
        }
        df = pd.DataFrame(data)
        captured = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = captured
        user_code.lab_result_alert(df)
        sys.stdout = sys_stdout
        output = normalize_text(captured.getvalue())
        _dynamic_test(
            self,
            "2" in output,
            "Correct total number of high glucose patients printed",
            f"Expected '2' in output, got: {output}"
        )

    def test_only_glucose_above_180_included(self):
        import user_code
        importlib.reload(user_code)
        data = {
            'Patient': ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve'],
            'Test': ['glucose', 'glucose', 'cholesterol', 'glucose', 'glucose'],
            'Value': [170, 200, 190, 185, 160]
        }
        df = pd.DataFrame(data)
        captured = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = captured
        user_code.lab_result_alert(df)
        sys.stdout = sys_stdout
        output = normalize_text(captured.getvalue())
        _dynamic_test(
            self,
            "alice" not in output and "eve" not in output and "charlie" not in output,
            "Only glucose tests above 180 are included in output",
            f"Unexpected patients included in output: {output}"
        )

    def test_no_high_glucose_patients(self):
        import user_code
        importlib.reload(user_code)
        data = {
            'Patient': ['Alice', 'Bob', 'Charlie'],
            'Test': ['glucose', 'glucose', 'glucose'],
            'Value': [100, 120, 180]
        }
        df = pd.DataFrame(data)
        captured = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = captured
        user_code.lab_result_alert(df)
        sys.stdout = sys_stdout
        output = normalize_text(captured.getvalue())
        _dynamic_test(
            self,
            output.strip() == "0",
            "Prints only 0 when no high glucose patients",
            f"Expected only '0' in output, got: {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: Lab Result Alert System

解答