In clinical practice, comparing lab results across different patient groups can reveal important trends and differences that guide diagnosis and treatment. Suppose you have a DataFrame with two columns: `diagnosis`, which indicates each patient's diagnosis group, and `glucose_level`, which records their blood glucose measurement. To visually compare glucose levels between these diagnosis groups, you can use a **boxplot**, a powerful tool for summarizing the distribution of lab values within each category. This approach helps you quickly spot differences, outliers, and trends among patient populations.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

# Example DataFrame: each row is a patient with a diagnosis and glucose level
data = {
    "diagnosis": ["Diabetes", "Diabetes", "Healthy", "Healthy", "Prediabetes", "Diabetes", "Prediabetes", "Healthy"],
    "glucose_level": [180, 175, 95, 90, 130, 200, 140, 100]
}
df = pd.DataFrame(data)

# Create a boxplot comparing glucose levels for each diagnosis group
plt.figure(figsize=(8, 6))
sns.boxplot(x="diagnosis", y="glucose_level", data=df)

# Add a title and axis labels
plt.title("Glucose Level Comparison by Diagnosis")
plt.xlabel("Diagnosis Group")
plt.ylabel("Glucose Level (mg/dL)")

# Display the plot
plt.show()


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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Patch plt.show so it doesn't block
        self._orig_show = plt.show
        plt.show = lambda *a, **k: None
        # Remove user_code from sys.modules if present
        if "user_code" in sys.modules:
            del sys.modules["user_code"]
    def tearDown(self):
        plt.show = self._orig_show
        if "user_code" in sys.modules:
            del sys.modules["user_code"]

    def test_boxplot_created(self):
        import user_code
        importlib.reload(user_code)
        # Check that a boxplot was created with correct axes labels
        found_boxplot = False
        for ax in plt.gcf().axes:
            for artist in ax.get_children():
                if isinstance(artist, matplotlib.patches.PathPatch):
                    found_boxplot = True
        _dynamic_test(
            self,
            found_boxplot,
            "Boxplot was created on the figure.",
            "No boxplot found on the figure."
        )

    def test_axis_labels(self):
        import user_code
        importlib.reload(user_code)
        ax = plt.gca()
        xlabel = ax.get_xlabel()
        ylabel = ax.get_ylabel()
        _dynamic_test(
            self,
            xlabel == "Diagnosis Group",
            "X-axis label is correctly set to 'Diagnosis Group'",
            f"Expected xlabel 'Diagnosis Group', got '{xlabel}'"
        )
        _dynamic_test(
            self,
            ylabel == "Glucose Level (mg/dL)",
            "Y-axis label is correctly set to 'Glucose Level (mg/dL)'",
            f"Expected ylabel 'Glucose Level (mg/dL)', got '{ylabel}'"
        )

    def test_title(self):
        import user_code
        importlib.reload(user_code)
        ax = plt.gca()
        title = ax.get_title()
        _dynamic_test(
            self,
            title == "Glucose Level Comparison by Diagnosis",
            "Plot title is correctly set.",
            f"Expected title 'Glucose Level Comparison by Diagnosis', got '{title}'"
        )

    def test_boxplot_x_axis_categories(self):
        import user_code
        importlib.reload(user_code)
        ax = plt.gca()
        actual_labels = [tick.get_text() for tick in ax.get_xticklabels()]
        expected_labels = sorted(["Diabetes", "Healthy", "Prediabetes"])
        actual_labels_sorted = sorted([l for l in actual_labels if l])
        _dynamic_test(
            self,
            actual_labels_sorted == expected_labels,
            "X-axis has correct diagnosis group labels.",
            f"Expected x-axis labels {expected_labels}, got {actual_labels_sorted}"
        )

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 healthcare professionals, focusing on real-world data analysis, visualization, and automation scenarios in the medical field. Learn to harness Python's power to streamline healthcare workflows, analyze patient data, and visualize medical trends.

Explore the essentials of working with healthcare data in Python, including data structures, importing datasets, and basic data cleaning tailored to medical records.

Master the art of visualizing healthcare data to uncover insights and communicate findings effectively using Python's plotting libraries.

Automate repetitive healthcare tasks and generate insightful reports using Python, streamlining workflows and improving efficiency.

Challenge: Lab Result Comparison

Soluzione