Summary  
This chapter introduces Python’s datetime module by showing how to create date, time, and datetime objects and access their year, month, day, hour, minute, and second attributes.

General domain of usage  
Time series data analysis and manipulation

from datetime import date, time, datetime

# Creating a date object
d = date(2024, 7, 4)

# Creating a time object
t = time(15, 30, 45)

# Creating a datetime object
dt = datetime(2024, 7, 4, 15, 30, 45)

# Accessing attributes
year = dt.year
month = dt.month
day = dt.day
hour = dt.hour
minute = dt.minute
second = dt.second

print("Date object:", d)
print("Time object:", t)
print("Datetime object:", dt)
print("Year:", year)
print("Month:", month)
print("Day:", day)
print("Hour:", hour)
print("Minute:", minute)
print("Second:", second)

When working with time series data, you often need to represent dates and times in a structured way. Python's `datetime` module provides three primary classes for this purpose: **`date`**, **`time`**, and **`datetime`**. 

The **`date`** class is used to represent a calendar date (year, month, and day) without any time information. For instance, `date(2024, 7, 4)` creates a date object for July 4, 2024. 

The **`time`** class captures a time of day independent of any particular date. By calling `time(15, 30, 45)`, you create a time object for 3:30:45 PM. 

The **`datetime`** class combines both date and time into a single object, such as `datetime(2024, 7, 4, 15, 30, 45)`, representing July 4, 2024, at 3:30:45 PM. 

Once you have a `datetime` object, you can access its individual components using attributes like `year`, `month`, `day`, `hour`, `minute`, and `second`. These attributes allow you to extract and manipulate specific parts of the date and time as needed for your analysis. Creating and working with these objects forms the foundation for handling time series data in Python.

import ast
import re   
import importlib
import csv
import unittest
import sys
import types
from datetime import datetime

class TestTask(unittest.TestCase):
    
    def setUp(self):
        # Відключаємо print перед кожним тестом
        def fake_print(*args, **kwargs):
            pass
        self.orig_print = __builtins__["print"]
        __builtins__["print"] = fake_print

    def tearDown(self):
        # Повертаємо print після кожного тесту
        __builtins__["print"] = self.orig_print

    def test_1_function_exists(self):
        import user_code
        importlib.reload(user_code)
        
        func = getattr(user_code, 'extract_date_parts', None)
        _dynamic_test(self, func is not None, "extract_date_parts function exists", "extract_date_parts function is not defined")

    def test_2_function_logic(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'extract_date_parts', None)
        
        if func is None:
            _dynamic_test(self, False, "Function correctly returns year, month, and day", "extract_date_parts function is not defined")
            return

        condition = False
        success_msg = "Function correctly returns year, month, and day"
        fail_msg = ""
        
        try:
            test_dt = datetime(2022, 12, 25)
            result = func(test_dt) 
            condition = (result == (2022, 12, 25))
            fail_msg = f"Function returned incorrect values: {result}"
        except TypeError:
            fail_msg = "Function is missing the date parameter."
        except Exception as e:
            fail_msg = f"Function raised an error: {e}"
            
        _dynamic_test(self, condition, success_msg, fail_msg)

    def test_3_year_variable(self):
        import user_code
        importlib.reload(user_code)
        
        year = getattr(user_code, 'year', None)
        _dynamic_test(self, year == 2022, "Variable 'year' is 2022", f"Expected year 2022, got {year}")

    def test_4_month_variable(self):
        import user_code
        importlib.reload(user_code)
        
        month = getattr(user_code, 'month', None)
        _dynamic_test(self, month == 12, "Variable 'month' is 12", f"Expected month 12, got {month}")

    def test_5_day_variable(self):
        import user_code
        importlib.reload(user_code)
        
        day = getattr(user_code, 'day', None)
        _dynamic_test(self, day == 25, "Variable 'day' is 25", f"Expected day 25, got {day}")


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.

Datetime Objects in Python

Ratkaisu