Consistent text formatting is essential for reliable data analysis and grouping. When text data contains a mix of uppercase, lowercase, or capitalized words, grouping and comparison operations can yield misleading results. For instance, `"Apple"`, `"apple"`, and `"APPLE"` might all refer to the same value, but without standardization, they are treated as distinct entries. By ensuring that all text values in a column use the same case, you simplify grouping and aggregation, reduce errors, and make your data easier to work with.

import pandas as pd

data = {
    "fruit": ["Apple", "banana", "ORANGE", "apple", "Banana", "orange"],
    "quantity": [5, 3, 4, 2, 1, 6]
}
df = pd.DataFrame(data)
print(df)

### Capitalizing Text for Consistency

Another useful approach is to convert text to capitalized case, where only the first letter of each value is uppercase and the rest are lowercase. This style is often used for names or titles. You can use the `str.capitalize()` method in pandas to achieve this. For example:

```python
import pandas as pd

data = {
    "fruit": ["Apple", "banana", "ORANGE", "apple", "Banana", "orange"],
    "quantity": [5, 3, 4, 2, 1, 6]
}
df = pd.DataFrame(data)
df["fruit"] = df["fruit"].str.capitalize()
print(df)
```

This will output:

```
    fruit  quantity
0   Apple         5
1  Banana         3
2  Orange         4
3   Apple         2
4  Banana         1
5  Orange         6
```

Using `str.capitalize()` ensures that each entry starts with an uppercase letter, which can be helpful when preparing data for presentation or matching a specific format.

import pandas as pd

data = {
    "fruit": ["Apple", "banana", "ORANGE", "apple", "Banana", "orange"],
    "quantity": [5, 3, 4, 2, 1, 6]
}
df = pd.DataFrame(data)

# Standardize text case using str.capitalize()
df_capitalized = df.copy()
df_capitalized["fruit"] = df_capitalized["fruit"].str.capitalize()
print(df_capitalized)


import unittest
import user_code
import ast
import re   
import unittest
import pandas as pd
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        self.data = {
            "fruit": ["Apple", "banana", "ORANGE", "apple", "Banana", "orange"],
            "quantity": [5, 3, 4, 2, 1, 6]
        }
        self.df = pd.DataFrame(self.data)

    def test_column_lowercase(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.standardize_column_lowercase(self.df, "fruit")
        expected = ["apple", "banana", "orange", "apple", "banana", "orange"]
        actual = list(result["fruit"])
        _dynamic_test(
            self,
            actual == expected,
            "All values in 'fruit' column are lowercase.",
            f"Expected all lowercase: {expected}, got: {actual}.",
        )

    def test_other_columns_unchanged(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.standardize_column_lowercase(self.df, "fruit")
        expected = list(self.df["quantity"])
        actual = list(result["quantity"])
        _dynamic_test(
            self,
            actual == expected,
            "Other columns remain unchanged.",
            f"Expected 'quantity' column unchanged: {expected}, got: {actual}.",
        )

    def test_original_df_not_modified(self):
        import user_code
        importlib.reload(user_code)
        df_copy = self.df.copy()
        _ = user_code.standardize_column_lowercase(self.df, "fruit")
        _dynamic_test(
            self,
            self.df.equals(df_copy),
            "Original DataFrame is not modified.",
            "Original DataFrame was modified.",
        )

    def test_already_lowercase(self):
        import user_code
        importlib.reload(user_code)
        df_lower = pd.DataFrame({"col": ["a", "b", "c"]})
        result = user_code.standardize_column_lowercase(df_lower, "col")
        expected = ["a", "b", "c"]
        actual = list(result["col"])
        _dynamic_test(
            self,
            actual == expected,
            "Handles columns that are already lowercase.",
            f"Expected already lowercase: {expected}, got: {actual}.",
        )

    def test_mixed_case(self):
        import user_code
        importlib.reload(user_code)
        df_mixed = pd.DataFrame({"col": ["Aaa", "BBb", "ccC"]})
        result = user_code.standardize_column_lowercase(df_mixed, "col")
        expected = ["aaa", "bbb", "ccc"]
        actual = list(result["col"])
        _dynamic_test(
            self,
            actual == expected,
            "Handles columns with mixed-case strings.",
            f"Expected all lowercase: {expected}, got: {actual}.",
        )

    def test_non_target_column(self):
        import user_code
        importlib.reload(user_code)
        df = pd.DataFrame({"col1": ["A", "B"], "col2": ["X", "Y"]})
        result = user_code.standardize_column_lowercase(df, "col1")
        expected_col2 = ["X", "Y"]
        _dynamic_test(
            self,
            list(result["col2"]) == expected_col2,
            "Non-target columns remain unchanged.",
            f"Expected 'col2' unchanged: {expected_col2}, got: {list(result['col2'])}.",
        )

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()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    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] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

Master essential data cleaning techniques in Python using powerful libraries and practical tasks. This course is designed for learners with intermediate Python skills who want to efficiently prepare and clean data for analysis and machine learning.

Explore the core concepts of data cleaning, why it matters, and the essential tools and techniques in Python.

Delve deeper into techniques for managing missing and duplicate data using pandas and numpy.

Focus on techniques for making data consistent, correcting errors, and detecting outliers.

Challenge: Standardize Text Case

Capitalizing Text for Consistency

Solution