Before you begin automating the cleaning of employee name lists, it is important to recall some useful string methods in Python. When dealing with inconsistent capitalization and unwanted spaces in names, you can use the `strip()` method to remove leading and trailing spaces, and the `title()` method to ensure each word in the name is properly capitalized.

name = "   jAnE doE   "
cleaned_name = name.strip().title()
print(cleaned_name)  # Output: Jane Doe

To process a list of employee names, you should apply both `strip()` and `title()` to each item in the list. This will ensure that every name is formatted consistently, making your HR records cleaner and easier to use in automated workflows.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):
    def test_no_leading_or_trailing_spaces(self):
        import user_code
        importlib.reload(user_code)
        names = ["  anna smith  ", " BOB JONES ", "carol johnson   ", "  dave miller "]
        result = user_code.clean_employee_names(names)
        _dynamic_test(
            self,
            all(name == name.strip() for name in result),
            "All names have no leading or trailing spaces.",
            f"Some names still have leading or trailing spaces: {result}",
        )

    def test_title_case(self):
        import user_code
        importlib.reload(user_code)
        names = ["  aLiCe sMIth  ", "bob JONES", "CarOL johnson", "DAVE MILLER"]
        result = user_code.clean_employee_names(names)
        expected = [name.title() for name in ["aLiCe sMIth", "bob JONES", "CarOL johnson", "DAVE MILLER"]]
        _dynamic_test(
            self,
            result == expected,
            "All names are title-cased correctly.",
            f"Expected: {expected}, got: {result}",
        )

    def test_length_unchanged(self):
        import user_code
        importlib.reload(user_code)
        names = ["John Doe", " Jane Smith ", "bob jones"]
        result = user_code.clean_employee_names(names)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == len(names),
            "Returned list has the same number of items as input.",
            f"Expected length {len(names)}, got {len(result)}",
        )

    def test_already_clean_names(self):
        import user_code
        importlib.reload(user_code)
        names = ["Jane Smith", "Bob Jones", "Carol Johnson"]
        result = user_code.clean_employee_names(names)
        _dynamic_test(
            self,
            result == names,
            "Function leaves already clean names unchanged.",
            f"Expected: {names}, got: {result}",
        )

    def test_inconsistent_names(self):
        import user_code
        importlib.reload(user_code)
        names = ["   aLICE   sMith  ", "BOB jOnes", "   carol   JOHNSON", "  dave miller "]
        result = user_code.clean_employee_names(names)
        expected = ["Alice Smith", "Bob Jones", "Carol Johnson", "Dave Miller"]
        _dynamic_test(
            self,
            result == expected,
            "Function handles inconsistent formatting correctly.",
            f"Expected: {expected}, got: {result}",
        )

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: Clean Employee Name List

Ratkaisu

Challenge: Clean Employee Name List

Ratkaisu