Visualizing a patient's **blood pressure trends over time** is a crucial skill for healthcare professionals who want to quickly assess changes and patterns in vital signs. To accomplish this, you will use a DataFrame containing `date` and `blood_pressure` columns, and create a line plot that clearly communicates this information. This task will help you practice turning raw medical data into an informative visual report suitable for a patient's medical record.

You can use the `plt.savefig()` function to save your plot as an image file, which can then be included in electronic medical records or shared with other healthcare professionals for review.

Note


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import os
import pandas as pd
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        # Remove the image file if it exists before each test
        self.plot_file = "bp_trend.png"
        if os.path.exists(self.plot_file):
            os.remove(self.plot_file)

    def tearDown(self):
        # Clean up image file after each test
        if os.path.exists(self.plot_file):
            os.remove(self.plot_file)

    def test_plot_file_created(self):
        import user_code
        importlib.reload(user_code)
        data = {
            "date": [
                "2024-01-01", "2024-01-10", "2024-01-20", "2024-02-01",
                "2024-02-15", "2024-03-01", "2024-03-10", "2024-03-20"
            ],
            "blood_pressure": [120, 122, 118, 125, 130, 128, 126, 124]
        }
        df = pd.DataFrame(data)
        func = getattr(user_code, 'plot_bp_trend', None)
        _dynamic_test(
            self,
            callable(func),
            "plot_bp_trend function exists",
            "plot_bp_trend function is not defined",
        )
        func(df)
        _dynamic_test(
            self,
            os.path.exists(self.plot_file),
            "Plot image file 'bp_trend.png' was created",
            "Plot image file 'bp_trend.png' was not created",
        )

    def test_plot_with_string_dates(self):
        import user_code
        importlib.reload(user_code)
        data = {
            "date": [
                "2024-05-01", "2024-05-10", "2024-05-20"
            ],
            "blood_pressure": [115, 117, 116]
        }
        df = pd.DataFrame(data)
        func = getattr(user_code, 'plot_bp_trend', None)
        _dynamic_test(
            self,
            callable(func),
            "plot_bp_trend function is callable",
            "plot_bp_trend function is not callable",
        )
        func(df)
        _dynamic_test(
            self,
            os.path.exists(self.plot_file),
            "Plot image file 'bp_trend.png' created from string dates",
            "Plot image file 'bp_trend.png' not created from string dates",
        )

    def test_plot_with_datetime_dates(self):
        import user_code
        importlib.reload(user_code)
        data = {
            "date": pd.to_datetime([
                "2024-06-01", "2024-06-10", "2024-06-20"
            ]),
            "blood_pressure": [110, 112, 111]
        }
        df = pd.DataFrame(data)
        func = getattr(user_code, 'plot_bp_trend', None)
        _dynamic_test(
            self,
            callable(func),
            "plot_bp_trend function is callable for datetime dates",
            "plot_bp_trend function is not callable for datetime dates",
        )
        func(df)
        _dynamic_test(
            self,
            os.path.exists(self.plot_file),
            "Plot image file 'bp_trend.png' created from datetime dates",
            "Plot image file 'bp_trend.png' not created from datetime dates",
        )

    def test_plot_function_no_side_effect(self):
        import user_code
        importlib.reload(user_code)
        data = {
            "date": ["2024-07-01", "2024-07-02"],
            "blood_pressure": [100, 105]
        }
        df = pd.DataFrame(data)
        func = getattr(user_code, 'plot_bp_trend', None)
        _dynamic_test(
            self,
            callable(func),
            "plot_bp_trend function is callable for side effect test",
            "plot_bp_trend function is not callable for side effect test",
        )
        # Should not raise or modify input
        df_copy = df.copy()
        func(df)
        _dynamic_test(
            self,
            os.path.exists(self.plot_file),
            "Plot image file 'bp_trend.png' created in side effect test",
            "Plot image file 'bp_trend.png' not created in side effect test",
        )
        # Ensure input DataFrame is not modified
        _dynamic_test(
            self,
            df.equals(df_copy),
            "Input DataFrame was not modified by plot_bp_trend",
            "Input DataFrame was modified by plot_bp_trend",
        )

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: Blood Pressure Trend Visualization

Oplossing