Summary  
This chapter demonstrates how to convert a DataFrame column to datetime, set it as the index, and use string-based date slicing to efficiently select time-based subsets of data.  

General domain of usage  
Time series analysis

import pandas as pd

# Sample data with a date column
data = {
    "date": ["2023-01-01", "2023-01-15", "2023-02-01", "2023-02-20", "2023-03-05"],
    "value": [10, 15, 20, 25, 30]
}
df = pd.DataFrame(data)

# Convert the 'date' column to datetime
df["date"] = pd.to_datetime(df["date"])

# Set the 'date' column as the index
df = df.set_index("date")

# Select all rows from February 2023
february_data = df["2023-02"]

print(df)
print(february_data)

Setting a DataFrame's index to a datetime column is a foundational step in time series analysis with pandas. By converting the `date` column to datetime format and then using it as the index, you enable powerful, intuitive time-based operations. In the code above, you first create a DataFrame with a simple date and value structure. The `pd.to_datetime` function ensures that the `date` column is properly recognized as datetime objects, which is essential for accurate indexing and selection.

Once the `date` column is set as the index, you can easily perform time-based selections using string-based queries. For instance, selecting all rows from February 2023 is as straightforward as using `df["2023-02"]`. This approach is not only concise but also highly efficient, especially when working with large datasets. Datetime indexing allows you to quickly filter data by year, month, or even specific days, making it an indispensable tool for time series analysis. The ability to slice data by time periods streamlines workflows and enhances the clarity of your code, reducing the need for complex filtering logic.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import pandas as pd

class TestTask(unittest.TestCase):
    def setUp(self):
        self.df = pd.DataFrame({
            "date": [
                "2024-01-10",
                "2024-01-20",
                "2024-02-05",
                "2024-02-25",
                "2024-03-03"
            ],
            "sales": [100, 120, 130, 110, 150]
        })
        self.df_single = pd.DataFrame({
            "date": ["2024-02-15"],
            "sales": [200]
        })
        self.df_none = pd.DataFrame({
            "date": ["2024-01-10", "2024-01-20"],
            "sales": [100, 120]
        })

    def test_sets_datetime_index(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.select_month(self.df.copy(), "2024-02")
        _dynamic_test(
            self,
            result is not None and isinstance(result.index, pd.DatetimeIndex),
            "Index is set to DatetimeIndex.",
            f"Expected DatetimeIndex, got {type(result.index)}."
        )

    def test_returns_correct_rows_multiple(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.select_month(self.df.copy(), "2024-02")
        expected_dates = [pd.Timestamp("2024-02-05"), pd.Timestamp("2024-02-25")]
        _dynamic_test(
            self,
            result is not None and list(result.index) == expected_dates,
            "Returned only rows from the specified month (multiple rows).",
            f"Expected dates {expected_dates}, got {list(result.index)}."
        )
        expected_sales = [130, 110]
        _dynamic_test(
            self,
            result is not None and list(result["sales"]) == expected_sales,
            "Returned correct sales values for specified month.",
            f"Expected sales {expected_sales}, got {list(result['sales'])}."
        )

    def test_returns_correct_rows_single(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.select_month(self.df_single.copy(), "2024-02")
        expected_dates = [pd.Timestamp("2024-02-15")]
        _dynamic_test(
            self,
            result is not None and list(result.index) == expected_dates,
            "Returned row for single matching date.",
            f"Expected index {expected_dates}, got {list(result.index)}."
        )
        expected_sales = [200]
        _dynamic_test(
            self,
            result is not None and list(result["sales"]) == expected_sales,
            "Returned correct sales value for single row.",
            f"Expected sales {expected_sales}, got {list(result['sales'])}."
        )

    def test_returns_empty_for_no_match(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.select_month(self.df_none.copy(), "2024-02")
        _dynamic_test(
            self,
            result is not None and result.empty,
            "Returned empty DataFrame when no dates match the month.",
            f"Expected empty DataFrame, 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

Establish foundational skills by manipulating datetime objects, indexing temporal data, utilizing interpolation techniques to impute missing anomalies, ultimately generating chronological visualizations.

Comprehensive coverage of time series fundamentals, from understanding data structure to visualization and handling missing values.

Datetime Indexing in Pandas

Solution