You have learned how to use **Python lists** to store HR data and how to perform calculations using elements from these lists. When analyzing employee turnover, it is common to have two lists: one containing the number of **employee departures** for each year, and another containing the **average headcount** for each year. By processing these lists **element-wise**, you can calculate important HR metrics such as the **turnover rate** for each year.

departures_per_year = [8, 10, 7, 12]
average_headcount_per_year = [80, 85, 83, 90]
years = [2020, 2021, 2022, 2023]

for year, departures, headcount in zip(years, departures_per_year, average_headcount_per_year):
    turnover_rate = departures / headcount
    print(f"Year: {year} - Turnover Rate: {turnover_rate:.2%}")

When presenting turnover rates, it is helpful to display both the year and the calculated percentage in a clear format. You can use Python's **formatted string literals** (`f-strings`) to include the year and format the turnover rate as a percentage with two decimal places. This makes your output easy for stakeholders to read and interpret.


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_output_lines_and_content(self):
        import user_code

        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_turnover_rates(
                [2020, 2021, 2022],
                [5, 8, 6],
                [50, 60, 55]
            )
        output = f.getvalue().strip().splitlines()
        expected = [
            "Year: 2020 - Turnover Rate: 10.00%",
            "Year: 2021 - Turnover Rate: 13.33%",
            "Year: 2022 - Turnover Rate: 10.91%"
        ]
        _dynamic_test(
            self,
            len(output) == len(expected),
            "Correct number of output lines for each year",
            f"Expected {len(expected)} lines, got {len(output)}: {output}",
        )
        for i in range(len(expected)):
            _dynamic_test(
                self,
                normalize_text(expected[i]) == normalize_text(output[i]),
                f"Line {i+1} output is correct",
                f"Expected '{expected[i]}', got '{output[i]}'",
            )

    def test_turnover_rate_calculation(self):
        import user_code
        importlib.reload(user_code)
        years = [2018, 2019]
        departures = [2, 3]
        headcounts = [20, 30]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_turnover_rates(years, departures, headcounts)
        output = f.getvalue()
        _dynamic_test(
            self,
            "2018" in output and "10.00%" in output,
            "Turnover rate for 2018 is calculated and printed correctly",
            f"Expected turnover rate 10.00% for 2018 in output: {output}",
        )
        _dynamic_test(
            self,
            "2019" in output and "10.00%" in output,
            "Turnover rate for 2019 is calculated and printed correctly",
            f"Expected turnover rate 10.00% for 2019 in output: {output}",
        )

    def test_handles_empty_lists(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_turnover_rates([], [], [])
        output = f.getvalue().strip()
        _dynamic_test(
            self,
            output == "",
            "No output is printed for empty input lists",
            f"Expected no output for empty lists, 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: Yearly Turnover Analysis

Ratkaisu