Working with healthcare datasets often involves addressing missing values, as lab results may be incomplete due to a variety of reasons. Handling these gaps is essential before any analysis or modeling. Suppose you receive a DataFrame containing patient lab results, and you notice that some entries in the `cholesterol` column are missing. Your task is to prepare this data for further analysis by following a standard cleaning procedure.

import pandas as pd

# Sample DataFrame representing patient lab results
data = {
    "patient_id": [101, 102, 103, 104, 105],
    "cholesterol": [180, None, 210, None, 190]
}
df = pd.DataFrame(data)

# 1. Identify the number of missing values in 'cholesterol'
missing_count = df["cholesterol"].isnull().sum()
print("Number of missing values in 'cholesterol':", missing_count)

# 2. Fill missing values with the median cholesterol value
median_chol = df["cholesterol"].median()
df["cholesterol"].fillna(median_chol, inplace=True)

# 3. Output the cleaned DataFrame
print("\nCleaned DataFrame:")
print(df)

By identifying and filling missing values with the **median**, you ensure that the dataset remains representative of the typical patient and is less skewed by outliers than if you used the **mean**. This approach is especially relevant in healthcare, where preserving the integrity of clinical data is crucial for accurate downstream analysis.


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

class TestTask(unittest.TestCase):
    def test_missing_count_var(self):
        import user_code
        importlib.reload(user_code)
        missing_count = getattr(user_code, 'missing_count', None)
        _dynamic_test(
            self,
            missing_count == 2,
            "Variable 'missing_count' is correctly set to 2.",
            f"Expected 'missing_count' to be 2, got {missing_count}"
        )

    def test_fill_with_median_df(self):
        import user_code
        importlib.reload(user_code)
        df = getattr(user_code, 'df', None)
        _dynamic_test(
            self,
            isinstance(df, pd.DataFrame),
            "Variable 'df' exists and is a pandas DataFrame.",
            "Variable 'df' is missing or not a DataFrame."
        )
        # Check that all cholesterol values are filled and correct
        expected = [205, 205.0, 187, 205.0, 220]
        actual = df["cholesterol"].tolist() if df is not None else None
        _dynamic_test(
            self,
            actual is not None and all(abs(a - e) < 1e-6 for a, e in zip(actual, expected)),
            "Missing values in 'cholesterol' are filled with median correctly.",
            f"Expected cholesterol column {expected}, got {actual}"
        )

    def test_output_content(self):
        import importlib
        import sys
        import io
        from contextlib import redirect_stdout
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        # Check missing count is printed
        _dynamic_test(
            self,
            "2" in output,
            "Output includes correct missing value count.",
            f"Expected missing value count '2' in output, got: {output}"
        )
        # Check cleaned DataFrame is printed
        expected_lines = [
            "201",
            "202",
            "203",
            "204",
            "205",
            "205.0",
            "205.0",
            "187.0",
            "205.0",
            "220.0"
        ]
        for line in expected_lines:
            _dynamic_test(
                self,
                line in output,
                f"Output includes line: {line}",
                f"Expected line '{line}' not found in output: {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 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: Clean Lab Results

Ratkaisu

patient_id	cholesterol
201	205
202
203	187
204
205	220