As you continue building your Python skills for HR tasks, you need to be comfortable looping through lists and using **string formatting** to create personalized messages. These skills let you automate communication tasks, such as generating welcome emails for new employees, with just a few lines of code. In this chapter, you will apply your knowledge of **list iteration** and **string formatting** to automate the creation of welcome messages.

employees = [
    {"name": "Alice", "email": "alice.smith@company.com"},
    {"name": "Bob", "email": "bob.jones@company.com"},
    {"name": "Charlie", "email": "charlie.brown@company.com"}
]

for employee in employees:
    message = f"Hello {employee['name']}, welcome to the company! Your email is {employee['email']}."
    print(message)

When generating messages for several employees, you can use **f-strings** or the `format()` method to insert each employee's name and email address directly into your message template. This approach ensures each message is unique and tailored to the individual, which is essential for effective HR communication.


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_correct_messages(self):
        import user_code
        importlib.reload(user_code)
        test_employees = [
            {"name": "Dana", "email": "dana.wilson@company.com"},
            {"name": "Eli", "email": "eli.turner@company.com"}
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.generate_welcome_messages(test_employees)
        output = normalize_text(f.getvalue())
        expected1 = normalize_text("Hello Dana, welcome to the company! Your email is dana.wilson@company.com.")
        expected2 = normalize_text("Hello Eli, welcome to the company! Your email is eli.turner@company.com.")
        _dynamic_test(
            self,
            expected1 in output and expected2 in output,
            "Function prints correct messages for multiple employees.",
            f"Expected messages not found in output: {output}"
        )

    def test_prints_for_empty_list(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.generate_welcome_messages([])
        output = f.getvalue().strip()
        _dynamic_test(
            self,
            output == "",
            "Function handles empty list by printing nothing.",
            f"Expected no output for empty list, got: {output}"
        )

    def test_uses_actual_name_and_email(self):
        import user_code
        importlib.reload(user_code)
        test_employees = [
            {"name": "Samira", "email": "samira.lee@company.com"}
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.generate_welcome_messages(test_employees)
        output = normalize_text(f.getvalue())
        expected = normalize_text("Hello Samira, welcome to the company! Your email is samira.lee@company.com.")
        _dynamic_test(
            self,
            expected in output,
            "Function prints personalized message using actual name and email.",
            f"Expected message not found in output: {output}"
        )

    def test_handles_multiple_employees(self):
        import user_code
        importlib.reload(user_code)
        test_employees = [
            {"name": "Alex", "email": "alex.green@company.com"},
            {"name": "Jamie", "email": "jamie.lane@company.com"},
            {"name": "Morgan", "email": "morgan.lee@company.com"}
        ]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.generate_welcome_messages(test_employees)
        output = normalize_text(f.getvalue())
        for emp in test_employees:
            expected = normalize_text(f"Hello {emp['name']}, welcome to the company! Your email is {emp['email']}.")
            _dynamic_test(
                self,
                expected in output,
                f"Message found for {emp['name']}.",
                f"Expected message for {emp['name']} not found in output: {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: Automate Welcome Email Generation

解答