Data cleaning is a foundational step in business data analysis. Without careful cleaning, your analyses may be skewed by missing values or inconsistent formatting, leading to inaccurate insights and decisions. For business analysts, ensuring that sales records are complete and standardized—such as by filling in missing sales numbers and making product names consistent—is essential for producing reliable reports and recommendations. Small inconsistencies, like varying capitalization or blank fields, can have a significant impact when aggregating or comparing data across products and periods. By mastering these cleaning techniques, you set the stage for more advanced analysis and trustworthy business intelligence.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.sales_data = [
            {'date': '2024-06-01', 'product': 'laptop', 'units_sold': 10, 'revenue': 15000},
            {'date': '2024-06-02', 'product': 'Laptop', 'units_sold': None, 'revenue': 14500},
            {'date': '2024-06-03', 'product': 'tablet', 'units_sold': 5, 'revenue': None},
            {'date': '2024-06-04', 'product': 'SMARTphone', 'units_sold': None, 'revenue': None},
        ]
        self.expected_cleaned = [
            {'date': '2024-06-01', 'product': 'Laptop', 'units_sold': 10, 'revenue': 15000},
            {'date': '2024-06-02', 'product': 'Laptop', 'units_sold': 0, 'revenue': 14500},
            {'date': '2024-06-03', 'product': 'Tablet', 'units_sold': 5, 'revenue': 0},
            {'date': '2024-06-04', 'product': 'Smartphone', 'units_sold': 0, 'revenue': 0},
        ]

    def test_units_sold_none_replaced(self):
        import user_code
        importlib.reload(user_code)
        cleaned = user_code.clean_sales_data(self.sales_data)
        all_replaced = all(
            cr['units_sold'] == er['units_sold']
            for cr, er in zip(cleaned, self.expected_cleaned)
        )
        _dynamic_test(
            self,
            all_replaced,
            "All None values in 'units_sold' replaced with 0 correctly.",
            "Some None values in 'units_sold' were not replaced with 0.",
        )

    def test_revenue_none_replaced(self):
        import user_code
        importlib.reload(user_code)
        cleaned = user_code.clean_sales_data(self.sales_data)
        all_replaced = all(
            cr['revenue'] == er['revenue']
            for cr, er in zip(cleaned, self.expected_cleaned)
        )
        _dynamic_test(
            self,
            all_replaced,
            "All None values in 'revenue' replaced with 0 correctly.",
            "Some None values in 'revenue' were not replaced with 0.",
        )

    def test_product_title_case(self):
        import user_code
        importlib.reload(user_code)
        cleaned = user_code.clean_sales_data(self.sales_data)
        all_title = all(
            cr['product'] == er['product']
            for cr, er in zip(cleaned, self.expected_cleaned)
        )
        _dynamic_test(
            self,
            all_title,
            "All product names are in title case.",
            "Some product names are not in title case.",
        )

    def test_returns_new_list(self):
        import user_code
        importlib.reload(user_code)
        cleaned = user_code.clean_sales_data(self.sales_data)
        _dynamic_test(
            self,
            cleaned is not self.sales_data and isinstance(cleaned, list),
            "Function returns a new list.",
            "Function does not return a new list.",
        )

    def test_original_list_unchanged(self):
        import user_code
        importlib.reload(user_code)
        orig = [rec.copy() for rec in self.sales_data]
        _ = user_code.clean_sales_data(self.sales_data)
        unchanged = self.sales_data == orig
        _dynamic_test(
            self,
            unchanged,
            "Original input list remains unchanged.",
            "Original input list was modified.",
        )

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

Unlock the power of Python to solve real-world business analysis problems. This course guides business analysts through practical Python applications, from data wrangling and visualization to automating reports and uncovering insights. Each section blends engaging theory with hands-on challenges inspired by business scenarios.

Learn how to use Python to clean, transform, and summarize business data for analysis. This section focuses on practical data wrangling skills essential for business analysts.

Discover how to use Python to create compelling visualizations that help communicate business insights effectively.

Harness Python to automate repetitive business analysis tasks, from generating reports to extracting actionable insights.

Challenge: Clean Sales Data

Oplossing

Challenge: Clean Sales Data

Oplossing