In your HR data analysis journey, you have learned how to work with **dictionaries** to store and process structured information, such as employee or department data. Iterating through a dictionary allows you to access each **key-value pair**, making it possible to examine or manipulate the data based on specific criteria. **Conditional logic**, such as using an `if` statement, helps you filter out only the information that meets certain requirements. This skill is essential when you want to identify trends or outliers—like departments with unusually high turnover rates.

# Example: Identifying departments with turnover above a threshold

department_turnover = {
    "Sales": 0.15,
    "Engineering": 0.08,
    "HR": 0.12,
    "Marketing": 0.09
}

threshold = 0.10

for department, turnover in department_turnover.items():
    if turnover > threshold:
        print(f"{department} has high turnover: {turnover:.0%}")

When presenting the results, it is helpful to format your output so that high-turnover departments stand out clearly. You can print each qualifying department on a new line, including both the department name and its turnover rate as a percentage. Using string formatting, such as `f"{value:.0%}"`, will display the turnover rate in an easy-to-read percentage format, making your HR reports more professional and actionable.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_prints_only_above_threshold(self):
        import user_code
        importlib.reload(user_code)
        data = {
            "Sales": 0.09,
            "Support": 0.12,
            "Tech": 0.10,
            "Admin": 0.14
        }
        threshold = 0.10
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_high_turnover_departments(data, threshold)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "support has high turnover: 12%" in output and "admin has high turnover: 14%" in output,
            "Prints only departments with turnover above the threshold.",
            f"Expected lines for Support and Admin above threshold, got: {output}"
        )
        _dynamic_test(
            self,
            "sales" not in output and "tech" not in output,
            "Does not print departments at or below threshold.",
            f"Departments at or below threshold should not appear, got: {output}"
        )

    def test_formatting_percentage(self):
        import user_code
        importlib.reload(user_code)
        data = {"A": 0.153}
        threshold = 0.10
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_high_turnover_departments(data, threshold)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "a has high turnover: 15%" in output,
            "Prints turnover rate as percentage with no decimals.",
            f"Expected '15%' formatting, got: {output}"
        )

    def test_no_departments_above_threshold(self):
        import user_code
        importlib.reload(user_code)
        data = {"A": 0.05, "B": 0.07}
        threshold = 0.10
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_high_turnover_departments(data, threshold)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            output.strip() == "",
            "Prints nothing when no departments are above threshold.",
            f"Expected empty output, got: {output}"
        )

    def test_exactly_on_threshold(self):
        import user_code
        importlib.reload(user_code)
        data = {"Alpha": 0.10, "Beta": 0.11}
        threshold = 0.10
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_high_turnover_departments(data, threshold)
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            "beta has high turnover: 11%" in output and "alpha" not in output,
            "Does not print departments with turnover equal to threshold, only above.",
            f"Expected only Beta, got: {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 HR professionals. Learn how to automate HR tasks, analyze employee data, and generate insightful reports using Python. Each section blends engaging theory with hands-on, real-world challenges relevant to HR workflows.

Learn how to use Python to automate common HR tasks, such as attendance tracking, onboarding, and document management.

Dive into data analysis techniques for HR, including calculating statistics, visualizing trends, and interpreting employee data.

Master the art of generating automated reports and actionable insights from HR data using Python.

Challenge: Identify High Turnover Departments

解答