Understanding **diversity metrics** is central to People Analytics. These metrics—such as **gender ratio** and **ethnic distribution**—enable you to assess representation and inclusivity within the workforce. By quantifying diversity, organizations can identify imbalances, track progress toward equity goals, and inform decision-making that fosters a more inclusive environment.

import pandas as pd
import matplotlib.pyplot as plt

# Example DataFrame of employee demographics
data = {
    "EmployeeID": [101, 102, 103, 104, 105, 106, 107, 108],
    "Gender": ["Female", "Male", "Female", "Male", "Female", "Female", "Male", "Male"],
    "Age": [34, 27, 29, 41, 36, 28, 32, 38],
    "Ethnicity": ["Hispanic", "White", "Black", "Asian", "White", "Black", "Asian", "Hispanic"]
}
df = pd.DataFrame(data)

# Basic matplotlib chart setup
plt.figure(figsize=(6,4))
plt.bar(df["Gender"].value_counts().index, df["Gender"].value_counts().values)
plt.title("Employee Count by Gender")
plt.xlabel("Gender")
plt.ylabel("Count")
plt.show()

plt.figure(figsize=(6,6))
plt.pie(df["Ethnicity"].value_counts().values, labels=df["Ethnicity"].value_counts().index, autopct='%1.1f%%')
plt.title("Ethnicity Distribution")
plt.show()

When interpreting diversity visualizations, focus on the **proportions** and **representation** of each group rather than just raw counts. Bar charts can quickly reveal gender imbalances, while pie charts highlight the presence or absence of particular ethnicities. Communicating these results effectively means translating visuals into actionable insights—such as noting underrepresented groups or shifts in workforce composition—to guide leadership in setting and evaluating diversity initiatives.


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

class TestTask(unittest.TestCase):
    def test_gender_ratio_dict(self):
        import user_code
        importlib.reload(user_code)
        gender_ratio = getattr(user_code, 'gender_ratio', None)
        expected = {'Female': 0.5, 'Male': 0.5}
        _dynamic_test(
            self,
            isinstance(gender_ratio, dict) and all(abs(gender_ratio.get(k, 0) - v) < 0.0001 for k, v in expected.items()),
            "Gender ratio dictionary is correct.",
            f"Expected gender ratio {expected}, got {gender_ratio}."
        )

    def test_ethnicity_proportion_dict(self):
        import user_code
        importlib.reload(user_code)
        ethnicity_proportion = getattr(user_code, 'ethnicity_proportion', None)
        expected = {'Hispanic': 0.25, 'White': 0.25, 'Black': 0.25, 'Asian': 0.25}
        _dynamic_test(
            self,
            isinstance(ethnicity_proportion, dict) and all(abs(ethnicity_proportion.get(k, 0) - v) < 0.0001 for k, v in expected.items()),
            "Ethnicity proportion dictionary is correct.",
            f"Expected ethnicity proportion {expected}, got {ethnicity_proportion}."
        )

    def test_bar_chart_gender(self):
        import user_code
        import matplotlib.pyplot as plt
        importlib.reload(user_code)
        # Check if a bar chart was created for gender
        found_bar = any(isinstance(ax, plt.Axes) and any([isinstance(child, plt.Rectangle) and child.get_height() in [4, 4] for child in ax.get_children()]) for ax in plt.get_fignums())
        # Since we can't check the plot visually, at least check that plt.show() was called (which clears figures)
        _dynamic_test(
            self,
            True,  # Always pass, as we can't inspect plots in headless test
            "Bar chart for gender was generated (visual check).",
            "Bar chart for gender was not generated."
        )

    def test_pie_chart_ethnicity(self):
        import user_code
        import matplotlib.pyplot as plt
        importlib.reload(user_code)
        # Can't check pie visually, but can check code runs
        _dynamic_test(
            self,
            True,
            "Pie chart for ethnicity was generated (visual check).",
            "Pie chart for ethnicity was not generated."
        )

    def test_summary_comments_present(self):
        # Check if summary comments are present in the code
        with open("user_code.py", "r") as f:
            code = f.read()
        keywords = [
            "The gender ratio shows the proportion of males to females",
            "The ethnicity proportions reveal the representation of each ethnic group",
            "Bar chart indicates if one gender is over- or underrepresented",
            "Pie chart visually demonstrates the diversity or concentration of ethnicities"
        ]
        found = all(any(normalize_text(line).find(normalize_text(key)) >= 0 for line in code.splitlines()) for key in keywords)
        _dynamic_test(
            self,
            found,
            "Summary comments are present in the code.",
            "Summary comments about findings are missing in the code."
        )

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: Analyze and Visualize Diversity

Oplossing