Bar charts are a powerful way to visualize categorical data, such as the number of adverse events associated with various drugs. By representing each drug as a separate bar and the event count as the bar's height, you can quickly compare the relative safety profiles of different medications. Highlighting the drug with the most adverse events draws immediate attention to potential problem areas, making it easier to focus on clinical priorities. Adding clear axis labels and a descriptive title ensures that your visualization communicates its message effectively to any audience. This approach is essential in pharmacy practice, where clear data presentation can support safer, more informed decision-making.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import pandas as pd
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        self.df = pd.DataFrame({
            'Drug': ['Aspirin', 'Paracetamol', 'Ibuprofen', 'Warfarin'],
            'AdverseEvents': [5, 3, 8, 2]
        })
        self.df2 = pd.DataFrame({
            'Drug': ['DrugA', 'DrugB', 'DrugC'],
            'AdverseEvents': [10, 25, 7]
        })

    def test_plot_bar_chart_exists(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        user_code.plot_adverse_events(self.df)
        fig = plt.gcf()
        axes = fig.get_axes()
        _dynamic_test(
            self,
            len(axes) > 0,
            "Bar chart is plotted (axes present)",
            "No axes found; chart was not plotted."
        )

    def test_x_and_y_labels_and_title(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        user_code.plot_adverse_events(self.df)
        ax = plt.gca()
        xlabel = ax.get_xlabel()
        ylabel = ax.get_ylabel()
        title = ax.get_title()
        _dynamic_test(
            self,
            normalize_text(xlabel) == normalize_text("Drug"),
            "X-axis label set correctly.",
            f"Expected x-axis label 'Drug', got '{xlabel}'."
        )
        _dynamic_test(
            self,
            normalize_text(ylabel) == normalize_text("Number of Adverse Events"),
            "Y-axis label set correctly.",
            f"Expected y-axis label 'Number of Adverse Events', got '{ylabel}'."
        )
        _dynamic_test(
            self,
            normalize_text(title) == normalize_text("Adverse Events per Drug"),
            "Title set correctly.",
            f"Expected title 'Adverse Events per Drug', got '{title}'."
        )

    def test_highlight_max_bar(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        user_code.plot_adverse_events(self.df)
        ax = plt.gca()
        bars = [bar for bar in ax.patches if bar.get_height() > 0]
        heights = [bar.get_height() for bar in bars]
        colors = [bar.get_facecolor() for bar in bars]
        max_idx = heights.index(max(heights))
        # Get all unique colors
        unique_colors = list(set(colors))
        _dynamic_test(
            self,
            len(unique_colors) > 1,
            "Max value bar is highlighted with a different color.",
            "All bars have the same color; max value not highlighted."
        )
        _dynamic_test(
            self,
            colors.count(colors[max_idx]) == 1,
            "Only one bar is highlighted as max.",
            "More than one bar highlighted as max."
        )

    def test_works_with_different_data(self):
        import user_code
        importlib.reload(user_code)
        plt.clf()
        user_code.plot_adverse_events(self.df2)
        ax = plt.gca()
        bars = [bar for bar in ax.patches if bar.get_height() > 0]
        heights = [bar.get_height() for bar in bars]
        max_idx = heights.index(max(heights))
        colors = [bar.get_facecolor() for bar in bars]
        unique_colors = list(set(colors))
        _dynamic_test(
            self,
            len(unique_colors) > 1,
            "Max value bar is highlighted with a different color for other data.",
            "All bars have the same color for other data; max value not highlighted."
        )
        _dynamic_test(
            self,
            colors.count(colors[max_idx]) == 1,
            "Only one bar is highlighted as max for other data.",
            "More than one bar highlighted as max for other data."
        )

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: Adverse Event Visualization

Ratkaisu