Understanding employee turnover is vital in people analytics because it provides insight into workforce stability and organizational health. **Turnover rate** measures the proportion of employees who leave an organization within a specific period, typically a year, relative to the average number of employees. This metric helps HR professionals identify trends, forecast staffing needs, and address potential issues related to retention. Visualizing turnover data makes patterns more accessible and actionable, supporting data-driven decision-making.

# Lists of employee names
current_employees = ["Alice", "Bob", "Charlie", "David", "Eva", "Frank", "Grace"]
former_employees = ["Helen", "Ian", "Jack"]

# Calculate turnover rate
total_employees = len(current_employees) + len(former_employees)
turnover_rate = (len(former_employees) / total_employees) * 100

# Basic bar chart setup
import matplotlib.pyplot as plt

categories = ["Current Employees", "Former Employees"]
counts = [len(current_employees), len(former_employees)]

plt.bar(categories, counts, color=["skyblue", "salmon"])
plt.ylabel("Number of Employees")
plt.title("Employee Status Overview")
plt.show()

When creating HR reports, annotating your charts with key metrics—such as the **turnover rate**—adds valuable context. To annotate a bar chart in `matplotlib`, you can use the `plt.text()` function to display the turnover rate directly above the bars or in the title. This helps stakeholders quickly interpret the results and understand the scale of workforce changes. Interpreting turnover data involves considering not just the percentage, but also the underlying causes and potential impact on the organization. High turnover may signal issues with employee satisfaction, culture, or management practices, while low turnover could indicate stability or, in some cases, stagnation.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import sys
import types

class TestTask(unittest.TestCase):
    def setUp(self):
        # Patch plt.show to prevent actual plot window during tests
        self._old_show = plt.show
        plt.show = lambda *a, **k: None
        import user_code
        importlib.reload(user_code)

    def tearDown(self):
        # Restore plt.show
        plt.show = self._old_show

    def test_turnover_rate_calculation(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show, capture figure
        plt.close('all')
        current = ["A", "B", "C", "D"]
        former = ["E", "F"]
        # We'll monkeypatch plt.text to capture annotation
        annotation = {}
        orig_text = plt.text
        def fake_text(x, y, s, **kwargs):
            annotation['text'] = s
            annotation['x'] = x
            annotation['y'] = y
            annotation['kwargs'] = kwargs
        plt.text = fake_text
        user_code.visualize_turnover(current, former)
        # Restore plt.text
        plt.text = orig_text
        expected_rate = (2 / 6) * 100
        found = annotation.get('text', '')
        _dynamic_test(
            self,
            f"Turnover Rate: {expected_rate:.1f}%" in found,
            "Correct turnover rate annotation calculated and displayed",
            f"Expected annotation 'Turnover Rate: {expected_rate:.1f}%', got '{found}'",
        )

    def test_bar_chart_categories_and_counts(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        current = ["X", "Y", "Z"]
        former = ["W"]
        # Spy on plt.bar
        bars = {}
        orig_bar = plt.bar
        def fake_bar(categories, counts, **kwargs):
            bars['categories'] = categories
            bars['counts'] = counts
            bars['kwargs'] = kwargs
            return orig_bar(categories, counts, **kwargs)
        plt.bar = fake_bar
        user_code.visualize_turnover(current, former)
        plt.bar = orig_bar
        expected_categories = ["Current Employees", "Former Employees"]
        expected_counts = [3, 1]
        _dynamic_test(
            self,
            bars.get('categories', []) == expected_categories and bars.get('counts', []) == expected_counts,
            "Bar chart displays correct categories and counts",
            f"Expected categories {expected_categories} and counts {expected_counts}, got {bars}",
        )

    def test_works_with_empty_former(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        annotation = {}
        orig_text = plt.text
        def fake_text(x, y, s, **kwargs):
            annotation['text'] = s
        plt.text = fake_text
        user_code.visualize_turnover(["A", "B", "C"], [])
        plt.text = orig_text
        found = annotation.get('text', '')
        _dynamic_test(
            self,
            "Turnover Rate: 0.0%" in found,
            "Function works with empty former_employees list and annotates turnover rate as 0.0%",
            f"Expected annotation 'Turnover Rate: 0.0%', got '{found}'",
        )

    def test_works_with_empty_current(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        annotation = {}
        orig_text = plt.text
        def fake_text(x, y, s, **kwargs):
            annotation['text'] = s
        plt.text = fake_text
        user_code.visualize_turnover([], ["X", "Y"])
        plt.text = orig_text
        found = annotation.get('text', '')
        _dynamic_test(
            self,
            "Turnover Rate: 100.0%" in found,
            "Function works with empty current_employees list and annotates turnover rate as 100.0%",
            f"Expected annotation 'Turnover Rate: 100.0%', got '{found}'",
        )

    def test_works_with_both_empty(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        annotation = {}
        orig_text = plt.text
        def fake_text(x, y, s, **kwargs):
            annotation['text'] = s
        plt.text = fake_text
        try:
            user_code.visualize_turnover([], [])
            plt.text = orig_text
            found = annotation.get('text', '')
            _dynamic_test(
                self,
                "Turnover Rate: 0.0%" in found,
                "Function handles both lists empty and annotates turnover rate as 0.0%",
                f"Expected annotation 'Turnover Rate: 0.0%', got '{found}'",
            )
        except Exception as e:
            plt.text = orig_text
            _dynamic_test(
                self,
                False,
                "Function handles both lists empty without error",
                f"Function raised error with both lists empty: {e}",
            )

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

Explore how Python can be leveraged to solve real-world People Analytics problems. This course covers essential data analysis, visualization, and machine learning techniques tailored for HR and workforce data, using only in-memory data structures and industry-relevant scenarios.

Learn the foundations of People Analytics and how Python can be used to analyze and interpret HR data for better decision-making.

Dive deeper into analyzing workforce trends, including diversity, performance, and engagement, using Python's data analysis and visualization tools.

Apply machine learning and advanced analytics to predict workforce outcomes and support strategic HR decisions.

Challenge: Calculate and Visualize Turnover

Ratkaisu