Recalling what you have learned about working with **lists** and **dictionaries**, you know that counting items in a list can be efficiently achieved using a **dictionary**, where each unique item serves as a key and its value is the count of occurrences. This is particularly useful in HR scenarios, such as determining how many employees belong to each department. You have also previously explored the basics of using `matplotlib` to create **bar charts**, which is a powerful way to visualize categorical data like department distributions.

departments = ["HR", "IT", "Finance", "IT", "HR", "Marketing", "Finance", "IT"]

# Count occurrences using a dictionary
department_counts = {}
for dept in departments:
    if dept in department_counts:
        department_counts[dept] += 1
    else:
        department_counts[dept] = 1

print(department_counts)
# Output: {'HR': 2, 'IT': 3, 'Finance': 2, 'Marketing': 1}

Once you have the counts for each department stored in a dictionary, you can pass the department names and their corresponding counts to **matplotlib**'s bar chart function. The keys of the dictionary will serve as the labels for each bar, and the values will determine the height of each bar, making it easy to visualize the employee distribution across departments.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
from unittest.mock import patch
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)
        self.departments = ["HR", "IT", "Finance", "IT", "HR", "Marketing", "Finance", "IT"]

    def test_employee_counts(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show to prevent actual plot display
        with patch("matplotlib.pyplot.show"):
            # Capture the department counts by temporarily replacing plt.bar
            counts = {}
            def fake_bar(labels, heights):
                for label, h in zip(labels, heights):
                    counts[label] = h
            with patch("matplotlib.pyplot.bar", side_effect=fake_bar):
                user_code.plot_department_distribution(self.departments)
            expected = {"HR": 2, "IT": 3, "Finance": 2, "Marketing": 1}
            _dynamic_test(
                self,
                counts == expected,
                "Function counts employees per department correctly.",
                f"Expected department counts {expected}, got {counts}.",
            )

    def test_x_labels(self):
        import user_code
        importlib.reload(user_code)
        with patch("matplotlib.pyplot.show"):
            labels_out = []
            def fake_bar(labels, heights):
                labels_out.extend(labels)
            with patch("matplotlib.pyplot.bar", side_effect=fake_bar):
                user_code.plot_department_distribution(self.departments)
            expected_labels = set(["HR", "IT", "Finance", "Marketing"])
            _dynamic_test(
                self,
                set(labels_out) == expected_labels,
                "Bar chart uses department names as labels.",
                f"Expected labels {expected_labels}, got {labels_out}",
            )

    def test_xlabel(self):
        import user_code
        importlib.reload(user_code)
        with patch("matplotlib.pyplot.show"):
            label = None
            def fake_xlabel(l):
                nonlocal label
                label = l
            with patch("matplotlib.pyplot.xlabel", side_effect=fake_xlabel):
                user_code.plot_department_distribution(self.departments)
            _dynamic_test(
                self,
                label == "Department",
                "X-axis label is set to 'Department'.",
                f"Expected x-axis label 'Department', got '{label}'.",
            )

    def test_ylabel(self):
        import user_code
        importlib.reload(user_code)
        with patch("matplotlib.pyplot.show"):
            label = None
            def fake_ylabel(l):
                nonlocal label
                label = l
            with patch("matplotlib.pyplot.ylabel", side_effect=fake_ylabel):
                user_code.plot_department_distribution(self.departments)
            _dynamic_test(
                self,
                label == "Number of Employees",
                "Y-axis label is set to 'Number of Employees'.",
                f"Expected y-axis label 'Number of Employees', got '{label}'.",
            )

    def test_title(self):
        import user_code
        importlib.reload(user_code)
        with patch("matplotlib.pyplot.show"):
            title = None
            def fake_title(t):
                nonlocal title
                title = t
            with patch("matplotlib.pyplot.title", side_effect=fake_title):
                user_code.plot_department_distribution(self.departments)
            _dynamic_test(
                self,
                title == "Employee Distribution by Department",
                "Chart title is set to 'Employee Distribution by Department'.",
                f"Expected title 'Employee Distribution by Department', got '{title}'.",
            )

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: Plot Department Distribution

Solution