Generating reports about **diagnosis frequency** is a common task in healthcare analytics, helping hospital administrators understand which conditions are most prevalent in their facilities. You are provided with a DataFrame containing a column labeled `"diagnosis"`, and your goal is to analyze the frequency of each unique diagnosis, sort them in descending order, and print the top three most common diagnoses. This mirrors the process of creating summary reports that inform resource allocation and planning.

To accomplish this, you will use the `pandas` library, which is well-suited for handling tabular healthcare data. The workflow involves counting the occurrences of each diagnosis, sorting the counts, and displaying the most frequent diagnoses.

import pandas as pd

# Example DataFrame with a 'diagnosis' column
data = {
    'diagnosis': [
        'Hypertension', 'Diabetes', 'Hypertension', 'Asthma', 'Diabetes',
        'Hypertension', 'Asthma', 'Asthma', 'Diabetes', 'Hypertension'
    ]
}
df = pd.DataFrame(data)

# Calculate the frequency of each unique diagnosis
diagnosis_counts = df['diagnosis'].value_counts()

# Sort the results in descending order (already sorted by value_counts)
# Print the top 3 most common diagnoses
top_3 = diagnosis_counts.head(3)
print("Top 3 most common diagnoses:")
print(top_3)

This script demonstrates a **typical approach** for summarizing diagnosis data. The `value_counts()` function computes the frequency of each unique value in the `"diagnosis"` column, and `head(3)` selects the top three. You would adapt this pattern to your own datasets to generate similar reports.

Now, apply this approach to a new DataFrame. Your task is to write code that calculates and prints the top three most common diagnoses in a given dataset.

import unittest
import ast
import re
import io
from contextlib import redirect_stdout
import pandas as pd


def strip_top_level_df_assignment(code: str) -> str:
    # Remove ONLY top-level statements like: df = ...
    tree = ast.parse(code)
    new_body = []
    for node in tree.body:
        if isinstance(node, ast.Assign):
            if any(isinstance(t, ast.Name) and t.id == "df" for t in node.targets):
                continue
        new_body.append(node)
    tree.body = new_body
    ast.fix_missing_locations(tree)
    return ast.unparse(tree)


class TestTask(unittest.TestCase):
    def setUp(self):
        self.df1 = pd.DataFrame({
            "diagnosis": [
                "Migraine", "Asthma", "Diabetes", "Asthma", "Hypertension",
                "Migraine", "Hypertension", "Asthma", "Diabetes", "Migraine",
                "Asthma", "Diabetes", "Hypertension", "Asthma", "Migraine"
            ]
        })
        self.df2 = pd.DataFrame({
            "diagnosis": ["A", "B", "C", "A", "B", "A", "C", "B", "B", "C", "C", "C"]
        })
        self.df3 = pd.DataFrame({
            "diagnosis": ["Flu", "Cold", "Flu", "Cold", "Flu"]
        })

    def run_user_code(self, df):
        with open("user_code.py", "r", encoding="utf-8") as f:
            code = f.read()

        # Ensure injected df is not overwritten
        code = strip_top_level_df_assignment(code)

        ns = {"pd": pd, "df": df.copy()}
        f_out = io.StringIO()
        with redirect_stdout(f_out):
            exec(code, ns)
        return f_out.getvalue()

    def test_top3_correct_output(self):
        output = self.run_user_code(self.df1)

        lines = [line.strip() for line in output.strip().split("\\n") if line.strip()]
        _dynamic_test(
            self,
            len(lines) >= 3,
            "Output has at least 3 lines for top-3 case.",
            f"Expected at least 3 lines, got: {lines}"
        )
        if len(lines) < 3:
            return

        _dynamic_test(
            self,
            ("Asthma" in lines[0] and "5" in lines[0]),
            "Line 1 is Asthma with count 5.",
            f"Expected Asthma(5) on line 1, got: {lines[0]}"
        )
        _dynamic_test(
            self,
            ("Migraine" in lines[1] and "4" in lines[1]),
            "Line 2 is Migraine with count 4.",
            f"Expected Migraine(4) on line 2, got: {lines[1]}"
        )

        # Third place is a tie: Diabetes(3) and Hypertension(3) are both valid
        third_ok = (
            ("Diabetes" in lines[2] and "3" in lines[2]) or
            ("Hypertension" in lines[2] and "3" in lines[2])
        )
        _dynamic_test(
            self,
            third_ok,
            "Line 3 is a valid tied third place (Diabetes(3) or Hypertension(3)).",
            f"Expected Diabetes(3) or Hypertension(3) on line 3, got: {lines[2]}"
        )

    def test_top3_with_different_data(self):
        output = self.run_user_code(self.df2)
        lines = [line.strip() for line in output.strip().split("\\n") if line.strip()]

        _dynamic_test(
            self,
            len(lines) >= 3,
            "Output has at least 3 lines for top-3 case on custom data.",
            f"Expected at least 3 lines, got: {lines}"
        )
        if len(lines) < 3:
            return

        _dynamic_test(self, ("C" in lines[0] and "5" in lines[0]),
                      "Line 1 is C with count 5.",
                      f"Expected C(5) on line 1, got: {lines[0]}")
        _dynamic_test(self, ("B" in lines[1] and "4" in lines[1]),
                      "Line 2 is B with count 4.",
                      f"Expected B(4) on line 2, got: {lines[1]}")
        _dynamic_test(self, ("A" in lines[2] and "3" in lines[2]),
                      "Line 3 is A with count 3.",
                      f"Expected A(3) on line 3, got: {lines[2]}")

    def test_less_than_three_diagnoses(self):
        output = self.run_user_code(self.df3)
        lines = [line.strip() for line in output.strip().split("\\n") if line.strip()]

        _dynamic_test(
            self,
            len(lines) == 2,
            "Output has exactly 2 lines when fewer than 3 unique diagnoses.",
            f"Expected only two diagnoses Flu(3), Cold(2). Got: {lines}"
        )
        if len(lines) != 2:
            return

        _dynamic_test(self, ("Flu" in lines[0] and "3" in lines[0]),
                      "Line 1 is Flu with count 3.",
                      f"Expected Flu(3) on line 1, got: {lines[0]}")
        _dynamic_test(self, ("Cold" in lines[1] and "2" in lines[1]),
                      "Line 2 is Cold with count 2.",
                      f"Expected Cold(2) on line 2, got: {lines[1]}")


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()


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: Diagnosis Frequency Report

Oplossing