When you are exploring patient data for potential risk factors, visualizing the relationship between variables like **age** and **lab results** can reveal important patterns. Suppose you have a DataFrame with two columns: `age` and `lab_result`. Your goal is to create a scatter plot that shows how lab results change with age, add a trendline to highlight the overall relationship, and make the plot readable by labeling the axes and adding a title. This mirrors how healthcare professionals might investigate whether certain lab values tend to increase or decrease as patients get older.

This approach helps you quickly identify possible correlations between patient age and lab values, which can guide further analysis or alert you to potential risk factors worth investigating.

Note


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

class TestTask(unittest.TestCase):
    def setUp(self):
        # Prepare test DataFrame
        self.data = {
            'age': [20, 30, 40, 50, 60],
            'lab_result': [2.5, 3.0, 4.0, 4.5, 5.0]
        }
        self.df = pd.DataFrame(self.data)
        # Patch user_code.df to self.df
        self.code = ""
        with open("user_code.py", "r") as f:
            self.code = f.read()
        self.code = self.code.replace("# Example DataFrame", "# Example DataFrame\\ndf = pd.DataFrame({})".format(self.data))

    def test_scatter_and_trendline(self):
        # Run code and check for scatter and trendline
        ns = {}
        plt.close('all')
        exec(self.code, ns)
        found_scatter = False
        found_line = False
        # Check the current axes for scatter and line
        for ax in plt.gcf().get_axes():
            for coll in ax.collections:
                # Scatter plot is a PathCollection
                if isinstance(coll, matplotlib.collections.PathCollection):
                    found_scatter = True
            for line in ax.get_lines():
                # Trendline is a Line2D
                if isinstance(line, matplotlib.lines.Line2D):
                    # Check if it's a regplot trendline by line width or color
                    found_line = True
        _dynamic_test(
            self,
            found_scatter,
            "Scatter plot is present on the figure.",
            "Scatter plot was not found on the figure."
        )
        _dynamic_test(
            self,
            found_line,
            "Trendline is present on the figure.",
            "Trendline was not found on the figure."
        )

    def test_axis_labels_and_title(self):
        ns = {}
        plt.close('all')
        exec(self.code, ns)
        ax = plt.gca()
        x_label = ax.get_xlabel()
        y_label = ax.get_ylabel()
        title = ax.get_title()
        _dynamic_test(
            self,
            x_label == "Age (years)",
            "X-axis label is correct.",
            f"Expected x-axis label 'Age (years)', got '{x_label}'."
        )
        _dynamic_test(
            self,
            y_label == "Lab Result",
            "Y-axis label is correct.",
            f"Expected y-axis label 'Lab Result', got '{y_label}'."
        )
        _dynamic_test(
            self,
            title == "Scatter Plot of Age vs. Lab Result with Trendline",
            "Plot title is correct.",
            f"Expected title 'Scatter Plot of Age vs. Lab Result with Trendline', got '{title}'."
        )

    def test_plot_displays(self):
        # Test that plt.show() is called (figure is created and not empty)
        ns = {}
        plt.close('all')
        exec(self.code, ns)
        figs = [fig for fig in map(plt.figure, plt.get_fignums()) if fig.axes]
        _dynamic_test(
            self,
            len(figs) > 0,
            "Plot is displayed (figure with axes exists).",
            "No figure with axes was created; plot may not have been displayed."
        )

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: Age vs. Lab Value Analysis

Soluzione