Summary  
This chapter explains how to estimate missing values in a sequence using interpolation methods—such as linear and time-based interpolation—to fill gaps based on neighboring data points.

General domain of usage  
Time series analysis

import pandas as pd
import numpy as np

# Create a time series with missing values
dates = pd.date_range("2023-01-01", periods=8, freq="D")
data = [1.0, np.nan, 3.0, np.nan, np.nan, 6.0, 7.0, np.nan]
ts = pd.Series(data, index=dates)
print("Original time series with missing values:")
print(ts)

# Linear interpolation
ts_linear = ts.interpolate(method="linear")
print("\nAfter linear interpolation:")
print(ts_linear)

# Time-based interpolation
ts_time = ts.interpolate(method="time")
print("\nAfter time-based interpolation:")
print(ts_time)

When working with time series data, missing values are common and can disrupt analysis. Interpolation is a technique to estimate these missing values based on the available data. The `pandas` library offers several interpolation methods through the `interpolate` method, each suited for different scenarios.

**Linear interpolation** is the most straightforward approach. It fills missing values by drawing a straight line between known points, making it appropriate when you expect changes between data points to be steady and gradual. This method is typically used for numeric time series where values change at a constant rate.

**Time-based interpolation** is similar but considers the actual time differences between data points. This is especially useful if your data has irregular time intervals or if the index is a `DatetimeIndex`. It estimates missing values by weighting them according to the distance in time, which can provide more accurate results when timestamps are unevenly spaced.

Other interpolation methods available in pandas include:
- **Polynomial interpolation** (`method="polynomial"`): Fits a polynomial curve to the data. Use this when you expect non-linear trends, but be cautious as higher-order polynomials can introduce artifacts;
- **Spline interpolation** (`method="spline"`): Fits a spline (piecewise polynomial) to the data. This method is helpful for smoother curves;
- **Pad/ffill and backfill/bfill**: These methods propagate the last valid observation forward or backward, respectively, and are best when missing values should simply repeat the previous or next value.

Choosing the right interpolation method depends on the nature of your data and the assumptions you can make about how values change over time. For most numeric time series with regularly spaced timestamps, linear interpolation is often sufficient. When working with irregular time intervals, time-based interpolation may provide better estimates.

import unittest
import ast
import re   
import importlib
import csv
import pandas as pd
import numpy as np

class TestTask(unittest.TestCase):
    def setUp(self):
        # Відключаємо print, щоб вивід студента не засмічував логи тестів
        def fake_print(*args, **kwargs):
            pass
        self.orig_print = __builtins__["print"]
        __builtins__["print"] = fake_print
        
        # Перезавантажуємо модуль перед кожним тестом
        self.module = importlib.import_module("user_code")
        importlib.reload(self.module)

    def tearDown(self):
        # Повертаємо print
        __builtins__["print"] = self.orig_print

    def test_1_returns_series(self):
        dates = pd.date_range("2023-02-01", periods=4, freq="D")
        data = [1.0, np.nan, 3.0, 4.0]
        ts = pd.Series(data, index=dates)
        
        try:
            result = self.module.fill_missing_linear(ts)
            _dynamic_test(
                self,
                isinstance(result, pd.Series),
                "Returned object is a pandas Series.",
                f"Expected pandas Series, got {type(result)}."
            )
        except Exception as e:
            _dynamic_test(self, False, "Returned object is a pandas Series.", f"Function raised an error: {e}")

    def test_2_linear_interpolation_values(self):
        dates = pd.date_range("2022-06-01", periods=6, freq="D")
        data = [2.0, np.nan, np.nan, 8.0, np.nan, 12.0]
        ts = pd.Series(data, index=dates)
        
        expected = pd.Series(
            [2.0, 4.0, 6.0, 8.0, 10.0, 12.0],
            index=dates
        )
        
        try:
            result = self.module.fill_missing_linear(ts)
            _dynamic_test(
                self,
                result is not None and result.equals(expected),
                "Series correctly interpolated using linear method.",
                f"Expected {expected.tolist()}, got {result.tolist() if result is not None else None}."
            )
        except Exception as e:
             _dynamic_test(self, False, "Series correctly interpolated using linear method.", f"Function raised an error: {e}")

    def test_3_no_nans_between_valid_numbers(self):
        dates = pd.date_range("2022-01-01", periods=5, freq="D")
        data = [5.0, np.nan, 7.0, np.nan, 9.0]
        ts = pd.Series(data, index=dates)
        
        try:
            result = self.module.fill_missing_linear(ts)
            nans = result.isna().sum() if result is not None else None
            _dynamic_test(
                self,
                result is not None and nans == 0,
                "All NaNs between valid numbers are filled.",
                f"Expected no NaNs, found {nans} NaNs in result."
            )
        except Exception as e:
            _dynamic_test(self, False, "All NaNs between valid numbers are filled.", f"Function raised an error: {e}")

    def test_4_leading_nan_remains(self):
        # By default in Pandas, linear interpolation forward-fills trailing NaNs.
        # However, leading NaNs remain NaN because there is no previous data to fill from.
        dates = pd.date_range("2022-03-01", periods=4, freq="D")
        data = [np.nan, 1.0, 3.0, np.nan]
        ts = pd.Series(data, index=dates)
        
        # Очікуємо, що перший NaN залишиться, а останній заповниться останнім відомим значенням (3.0)
        expected = pd.Series([np.nan, 1.0, 3.0, 3.0], index=dates)
        
        try:
            result = self.module.fill_missing_linear(ts)
            _dynamic_test(
                self,
                result is not None and result.equals(expected),
                "Leading NaNs remain while trailing NaNs are forward-filled.",
                f"Expected {expected.tolist()}, got {result.tolist() if result is not None else None}."
            )
        except Exception as e:
            _dynamic_test(self, False, "Leading NaNs remain while trailing NaNs are forward-filled.", f"Function raised an error: {e}")

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
    
    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 not assign_nodes:
        return code

    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.

Interpolation Techniques

Solution