DEV Community: Thiruvengadam Sakthivel

#05 -Python's Hidden Superpowers: Special (Magic) Methods Explained

Thiruvengadam Sakthivel — Wed, 05 Aug 2026 13:26:32 +0000

Welcome to Day 5! Special methods (also known as magic methods or dunder methods, short for "double underscore") allow your custom Python classes to hook into Python's built-in operators, syntax, and runtime protocols.

By implementing dunder methods, you make your custom objects act like built-in Python types (list, dict, int), enabling features like pretty printing, iteration, comparison, context management, and direct execution.

1. Categorizing Core Dunder Methods 🗂️

┌─────────────────────────────────────────────────────────────────────────────┐
│                            SPECIAL (MAGIC) METHODS                          │
├──────────────────┬───────────────────────┬──────────────────────────────────┤
│ Category         │ Dunder Method         │ Triggering Syntax / Operation    │
├──────────────────┼───────────────────────┼──────────────────────────────────┤
│ Representation   │ __str__(self)         │ str(obj), print(obj), f"{obj}"   │
│                  │ __repr__(self)        │ repr(obj), REPL output, debugging│
├──────────────────┼───────────────────────┼──────────────────────────────────┤
│ Sizing & Order   │ __len__(self)         │ len(obj)                         │
│                  │ __eq__(self, other)   │ obj1 == obj2                     │
│                  │ __lt__(self, other)   │ obj1 < obj2, sorted([obj1, obj2])│
├──────────────────┼───────────────────────┼──────────────────────────────────┤
│ Protocols        │ __iter__(self)        │ for item in obj:                 │
│                  │ __call__(self, *args) │ obj(*args) (callable instance)   │
├──────────────────┼───────────────────────┼──────────────────────────────────┤
│ Context Manager  │ __enter__(self)       │ with obj as resource:            │
│                  │ __exit__(...)         │ Exiting a with block             │
└──────────────────┴───────────────────────┴──────────────────────────────────┘

2. Topic Breakdown 💡

1. Object Representation: `str` vs `repr`

__str__: Returns a friendly, human-readable string representation intended for end-users (print(), f-strings).
__repr__: Returns an unambiguous representation intended for developers and debugging. Ideally, it looks like valid Python code to recreate the object.

class Book:
    def __init__(self, title: str, author: str):
        self.title = title
        self.author = author

    def __str__(self) -> str:
        return f"'{self.title}' by {self.author}"

    def __repr__(self) -> str:
        return f"Book(title={self.title!r}, author={self.author!r})"

b = Book("Designing Data-Intensive Applications", "Martin Kleppmann")
print(str(b))   # 'Designing Data-Intensive Applications' by Martin Kleppmann
print(repr(b))  # Book(title='Designing Data-Intensive Applications', author='Martin Kleppmann')

2. Sizing & Comparisons: `len`, `eq`, `lt`

__len__: Defines the behavior of len(obj). Must return a non-negative integer.
__eq__: Defines equality checks (==).
__lt__: Defines "less than" (<). Defining __lt__ automatically unlocks built-in sorting via sorted() or .sort().

class Task:
    def __init__(self, title: str, priority: int):
        self.title = title
        self.priority = priority

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Task):
            return NotImplemented
        return self.priority == other.priority

    def __lt__(self, other: 'Task') -> bool:
        return self.priority < other.priority

t1 = Task("Fix Critical Bug", priority=1)
t2 = Task("Update Docs", priority=3)

print(t1 < t2)  # True (1 < 3)

3. Iteration & Callables: `iter`, `call`

__iter__: Makes your object iterable, allowing it to be used in for loops, list comprehensions, and unpacked with *.
__call__: Allows an instance of a class to be invoked like a function.

class FactorialCalculator:
    def __call__(self, n: int) -> int:
        """Invoked when object is called like a function: calc(5)"""
        result = 1
        for i in range(1, n + 1):
            result *= i
        return result

calc = FactorialCalculator()
print(calc(5))  # Output: 120

4. Context Management: `enter`, `exit`

Enables the use of with statements to manage setup and teardown operations safely (e.g., file handling, locking, transaction management).

__enter__: Executed when entering the with block. Its return value is bound to the target variable (as target).
__exit__: Executed when leaving the with block, even if an exception occurs.

class TimerContext:
    import time

    def __enter__(self):
        import time
        self.start = time.perf_counter()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        import time
        elapsed = time.perf_counter() - self.start
        print(f"⏱️ Block executed in {elapsed:.4f} seconds")
        return False  # Do not suppress exceptions if any occurred

3. Practice Challenge: Custom `SmartBatch` Pipeline 🚀

Let's combine all 9 magic methods into a single production-ready data structure: a SmartBatch manager that acts as an iterable, comparable, callable context manager for tasks.

┌─────────────────────────────────────────────────────────────────────────────┐
│                             SMART BATCH ENGINE                              │
└─────────────────────────────────────────────────────────────────────────────┘

       [ with SmartBatch("Data Ingestion") as batch: ]
                             │
            ┌────────────────┴────────────────┐
            │       __enter__() Called        │  --> Opens Processing Window
            └────────────────┬────────────────┘
                             │
            ┌────────────────┴────────────────┐
            │   Batch Populated & Filtered    │
            │   • __len__()   --> Size Check  │
            │   • __call__()  --> Filtering   │
            │   • __iter__()  --> Unpacking   │
            │   • __lt__()    --> Sorting     │
            └────────────────┬────────────────┘
                             │
            ┌────────────────┴────────────────┐
            │       __exit__() Called         │  --> Validates & Flushes Batch
            └─────────────────────────────────┘

Step 1: Initialize Your Workspace

uv init oop_day5 && cd oop_day5
touch smart_batch.py

Step 2: Implement `smart_batch.py`

# smart_batch.py
from typing import List, Iterator, Any, Optional, Self
import time


class DataTask:
    """Represents an individual unit of work in the batch system."""

    def __init__(self, task_id: str, payload: str, priority: int):
        self.task_id = task_id
        self.payload = payload
        self.priority = priority  # Lower number = higher priority (1 is top priority)

    def __str__(self) -> str:
        """User-friendly representation."""
        return f"[{self.task_id}] {self.payload} (P{self.priority})"

    def __repr__(self) -> str:"""Developer debugging representation."""
        return f"DataTask(task_id={self.task_id!r}, payload={self.payload!r}, priority={self.priority})"

    def __eq__(self, other: object) -> bool:"""Equality based on task ID and priority."""
        if not isinstance(other, DataTask):
            return NotImplemented
        return self.task_id == other.task_id and self.priority == other.priority

    def __lt__(self, other: 'DataTask') -> bool:"""Enables native sorting based on priority."""
        return self.priority < other.priority


class SmartBatch:
    """A custom container demonstrating all key Python magic methods."""

    def __init__(self, name: str):
        self.name = name
        self.tasks: List[DataTask] = []
        self.is_active = False
        self._start_time: float = 0.0

    # 1. REPRESENTATION METHODS
    def __str__(self) -> str:
        return f"SmartBatch('{self.name}') containing {len(self.tasks)} task(s)"

    def __repr__(self) -> str:
        return f"SmartBatch(name={self.name!r}, tasks={self.tasks!r})"

    # 2. SIZING & COMPARISON METHODS
    def __len__(self) -> int:
        """Returns the number of tasks in the batch."""
        return len(self.tasks)

    def __eq__(self, other: object) -> bool:
        """Batches are equal if they share the same name and task count."""
        if not isinstance(other, SmartBatch):
            return NotImplemented
        return self.name == other.name and len(self) == len(other)

    def __lt__(self, other: 'SmartBatch') -> bool:
        """Allows batches to be compared/sorted by task count."""
        return len(self) < len(other)

    # 3. PROTOCOL METHODS
    def __iter__(self) -> Iterator[DataTask]:
        """Allows 'for task in batch:' iteration."""
        return iter(self.tasks)

    def __call__(self, max_priority: int) -> List[DataTask]:
        """Makes the batch instance callable to filter tasks on the fly!
        Example: filtered_tasks = batch(max_priority=2)
        """
        return [task for task in self.tasks if task.priority <= max_priority]

    # 4. CONTEXT MANAGER METHODS
    def __enter__(self) -> Self:
        """Opens processing window for 'with SmartBatch(...) as batch:'."""
        self.is_active = True
        self._start_time = time.perf_counter()
        print(f"🟢 [__enter__] Context Opened: Batch '{self.name}' processing started.")
        return self

    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> bool:
        """Flushes tasks and handles cleanup automatically on block exit."""
        elapsed = (time.perf_counter() - self._start_time) * 1000
        self.is_active = False

        if exc_type:
            print(f"❌ [__exit__] Batch processing failed with exception: {exc_val}")
            return False  # Propagate exception

        print(f"🏁 [__exit__] Context Closed: Flushed {len(self)} tasks in {elapsed:.2f}ms.")
        return True  # Exception handled cleanly


# ==========================================
# TEST EXECUTION SUITE
# ==========================================
if __name__ == "__main__":
    print("--- 1. Testing Representation & Equality ---")
    t1 = DataTask("T-101", "Process Order #882", priority=1)
    t2 = DataTask("T-102", "Send Confirmation Email", priority=3)
    t3 = DataTask("T-103", "Sync Analytics", priority=2)

    print(f"__str__  : {t1}")
    print(f"__repr__ : {repr(t1)}")
    print(f"__eq__   : t1 == t2 -> {t1 == t2}")

    print("\n--- 2. Testing Context Manager & Batch Operations ---")
    # Using __enter__ and __exit__ via 'with' statement
    with SmartBatch("Nightly ETL Pipeline") as batch:
        # Add tasks to batch
        batch.tasks.extend([t1, t2, t3])

        # Testing __len__
        print(f"\nBatch Length (__len__): {len(batch)}")
        print(f"Batch Description (__str__): {batch}")

        # Testing __iter__
        print("\nIterating through batch tasks (__iter__):")
        for task in batch:
            print(f"  └─ {task}")

        # Testing __call__ (Filtering by priority)
        print("\nFiltering batch using instance call (__call__ for max_priority <= 2):")
        high_priority_tasks = batch(max_priority=2)
        for hp_task in high_priority_tasks:
            print(f"  🔥 High Priority: {hp_task}")

        # Testing sorting (__lt__ on DataTask)
        print("\nSorting tasks in-place using __lt__:")
        batch.tasks.sort()
        for sorted_task in batch:
            print(f"  ⭐ Sorted: {sorted_task}")

    print("\n--- 3. Testing Batch Comparisons (__lt__ & __eq__) ---")
    batch_a = SmartBatch("Batch A")
    batch_b = SmartBatch("Batch B")

    batch_a.tasks.append(t1)
    batch_b.tasks.extend([t1, t2, t3])

    print(f"batch_a length: {len(batch_a)}, batch_b length: {len(batch_b)}")
    print(f"batch_a < batch_b (__lt__) : {batch_a < batch_b}")
    print(f"batch_a == batch_b (__eq__): {batch_a == batch_b}")

Step 3: Run & Verify Execution

uv run smart_batch.py

Output Summary

--- 1. Testing Representation & Equality ---
__str__  : [T-101] Process Order #882 (P1)
__repr__ : DataTask(task_id='T-101', payload='Process Order #882', priority=1)
__eq__   : t1 == t2 -> False

--- 2. Testing Context Manager & Batch Operations ---
🟢 [__enter__] Context Opened: Batch 'Nightly ETL Pipeline' processing started.

Batch Length (__len__): 3
Batch Description (__str__): SmartBatch('Nightly ETL Pipeline') containing 3 task(s)

Iterating through batch tasks (__iter__):
  └─ [T-101] Process Order #882 (P1)
  └─ [T-102] Send Confirmation Email (P3)
  └─ [T-103] Sync Analytics (P2)

Filtering batch using instance call (__call__ for max_priority <= 2):
  🔥 High Priority: [T-101] Process Order #882 (P1)
  🔥 High Priority: [T-103] Sync Analytics (P2)

Sorting tasks in-place using __lt__:
  ⭐ Sorted: [T-101] Process Order #882 (P1)
  ⭐ Sorted: [T-103] Sync Analytics (P2)
  ⭐ Sorted: [T-102] Send Confirmation Email (P3)
🏁 [__exit__] Context Closed: Flushed 3 tasks in 0.15ms.

--- 3. Testing Batch Comparisons (__lt__ & __eq__) ---
batch_a length: 1, batch_b length: 3
batch_a < batch_b (__lt__) : True
batch_a == batch_b (__eq__): False

#04 - Connecting Objects: Understanding Object Relationships in Python

Thiruvengadam Sakthivel — Sat, 25 Jul 2026 14:48:07 +0000

Welcome to Day 4! Up until now, we’ve focused on individual classes, encapsulation, and inheritance hierarchies. Today, we step into system architecture by exploring how independent objects interact and relate to one another in memory.

Understanding these four core relationships allows you to model complex real-world domains without forcing everything into rigid inheritance trees.

1. The Relationship Spectrum 📊

Object relationships differ primarily by coupling strength and lifecycle dependency (whether one object controls the creation and destruction of another).

┌─────────────────────────────────────────────────────────────────────────────┐
│                            OBJECT RELATIONSHIPS                             │
├─────────────┬─────────────┬──────────────────────┬──────────────────────────┤
│ Relationship│ Link Type   │ Lifecycle Bound?     │ Reference Storage        │
├─────────────┼─────────────┼──────────────────────┼──────────────────────────┤
│ Dependency  │ Uses-a      │ No (Temporary scope) │ Passed as method arg     │
│ Association │ Knows-a     │ No (Independent)     │ Stored field reference   │
│ Aggregation │ Has-a (Weak)│ No (Independent)     │ Stored reference list    │
│ Composition │ Has-a(Strong│ Yes (Parent controls)│ Created inside parent    │
└─────────────┴─────────────┴──────────────────────┴──────────────────────────┘

2. Breaking Down the 4 Relationships 🛠️

1. Dependency ("Uses-a")

The weakest relationship. Object A uses Object B temporarily to complete an operation (e.g., as a parameter in a method). Object A does not store a persistent reference to Object B.

class Printer:
    def print_document(self, content: str) -> None:
        print(f"🖨️ Printing: {content}")

class Report:
    def __init__(self, title: str):
        self.title = title

    # Dependency: Report uses Printer temporarily inside a method
    def export(self, printer: Printer) -> None:
        printer.print_document(f"Report Title: {self.title}")

2. Association ("Knows-a")

A structural connection where two objects communicate, but neither owns the other. Both have independent lifecycles.

class Student:
    def __init__(self, name: str):
        self.name = name

class Teacher:
    def __init__(self, name: str):
        self.name = name
        self.students: list[Student] = []  # Association: Knows about students

    def assign_student(self, student: Student) -> None:
        self.students.append(student)

3. Aggregation ("Has-a" — Weak Ownership)

A specialized form of association representing a whole-to-part relationship. The container object holds references to component objects, but if the container is destroyed, the components continue to exist independently.

class Book:
    def __init__(self, title: str):
        self.title = title

class Library:
    def __init__(self, name: str, books: list[Book]):
        self.name = name
        self.books = books  # Aggregation: Books exist outside the Library

# Books exist independently first
b1 = Book("Clean Code")
lib = Library("City Central", [b1])

# If 'lib' is deleted, 'b1' still exists in memory
del lib
print(b1.title)  # Output: Clean Code

4. Composition ("Has-a" — Strong Ownership)

The tightest relationship. The parent object owns and manages the lifecycle of the child object. The child is instantiated inside the parent and cannot exist without it. If the parent is destroyed, all child components are destroyed too.

class BuildingRoom:
    def __init__(self, room_number: str):
        self.room_number = room_number

class Building:
    def __init__(self, name: str):
        self.name = name
        # Composition: Rooms are created directly INSIDE Building
        self.rooms = [BuildingRoom("101"), BuildingRoom("102")]

# Rooms are completely tied to the lifecycle of Building
campus_building = Building("Science Hall")

3. Practice Challenge: University Management System 🎓

Let me walk you through a complete University Management System that combines all four object relationships in a single, cohesive architecture.

┌─────────────────────────────────────────────────────────────────────────────┐
│                     UNIVERSITY SYSTEM ARCHITECTURE                          │
└─────────────────────────────────────────────────────────────────────────────┘

       ┌────────────────┐                  ┌─────────────────┐
       │   University   │ ──(Composition)─►│   Department    │
       └────────────────┘                  └────────┬────────┘
                                                    │
                                               (Aggregation)
                                                    │
                                                    ▼
       ┌────────────────┐                  ┌─────────────────┐
       │    Student     │ ──(Association)─►│    Professor    │
       └───────┬────────┘                  └─────────────────┘
               │
          (Dependency)
               │
               ▼
       ┌────────────────┐
       │TranscriptPrinter│
       └────────────────┘

Step 1: Initialize Your Workspace

uv init oop_day4 && cd oop_day4
touch university_system.py

Step 2: Implement `university_system.py`

# university_system.py
from typing import List, Optional


# ==========================================
# 1. INDEPENDENT DOMAIN ENTITIES
# ==========================================
class Professor:
    """Independent entity used in Aggregation."""
    def __init__(self, prof_id: str, name: str, specialization: str):
        self.prof_id = prof_id
        self.name = name
        self.specialization = specialization

    def __repr__(self) -> str:
        return f"Prof. {self.name} ({self.specialization})"


class Student:
    """Independent entity used in Association and Dependency."""
    def __init__(self, student_id: str, name: str, gpa: float):
        self.student_id = student_id
        self.name = name
        self.gpa = gpa
        # Association: Student maintains references to advisor(s)
        self.advisor: Optional[Professor] = None

    def assign_advisor(self, professor: Professor) -> None:
        """Establishes an Association with a Professor."""
        self.advisor = professor
        print(f"🤝 [Association] {self.name} is now advised by {professor.name}")


# ==========================================
# 2. DEPENDENCY COMPONENT
# ==========================================
class TranscriptPrinter:
    """Utility service that demonstrates Dependency ("Uses-a")."""

    @staticmethod
    def print_transcript(student: Student) -> None:
        """Dependency: Receives Student as a temporary method argument."""
        print("\n==================================================")
        print(f"          OFFICIAL TRANSCRIPT: {student.name.upper()}     ")
        print("==================================================")
        print(f" Student ID : {student.student_id}")
        print(f" Current GPA: {student.gpa:.2f}")
        advisor_str = student.advisor.name if student.advisor else "None Assigned"
        print(f" Advisor    : {advisor_str}")
        print("--------------------------------------------------\n")


# ==========================================
# 3. AGGREGATION & COMPOSITION CONTAINERS
# ==========================================
class Department:
    """Component used in Composition by University, and Aggregation with Professors."""
    def __init__(self, name: str):
        self.name = name
        # Aggregation: Professors exist independently outside Department
        self.faculty: List[Professor] = []

    def add_faculty(self, professor: Professor) -> None:
        """Aggregation: Accepts externally created Professor objects."""
        self.faculty.append(professor)
        print(f"📚 [Aggregation] {professor.name} joined the {self.name} Department")


class University:
    """Root container illustrating Composition ("Has-a" Strong)."""
    def __init__(self, name: str):
        self.name = name
        # Composition: Departments are instantiated INSIDE University
        # Their lifecycle is strictly tied to this University instance
        self.departments: List[Department] = [
            Department("Computer Science"),
            Department("Mathematics"),
            Department("Physics")
        ]

    def get_department(self, name: str) -> Optional[Department]:
        for dept in self.departments:
            if dept.name.lower() == name.lower():
                return dept
        return None

    def display_structure(self) -> None:
        print(f"\n🏛️  University: {self.name}")
        print("--------------------------------------------------")
        for dept in self.departments:
            print(f"  🏢 Department: {dept.name}")
            if dept.faculty:
                for prof in dept.faculty:
                    print(f"     └─ Faculty: {prof}")
            else:
                print("     └─ Faculty: [No staff assigned]")


# ==========================================
# TEST EXECUTION SUITE
# ==========================================
if __name__ == "__main__":
    # --- 1. COMPOSITION DEMO ---
    # Creating University automatically instantiates its Departments
    mit = University("Massachusetts Institute of Technology")

    # --- 2. AGGREGATION DEMO ---
    # Create Professors independently (they exist on their own)
    prof_knuth = Professor("P-101", "Donald Knuth", "Algorithms")
    prof_euler = Professor("P-102", "Leonhard Euler", "Number Theory")

    # Aggregate professors into departments
    cs_dept = mit.get_department("Computer Science")
    math_dept = mit.get_department("Mathematics")

    if cs_dept:
        cs_dept.add_faculty(prof_knuth)
    if math_dept:
        math_dept.add_faculty(prof_euler)

    mit.display_structure()

    # --- 3. ASSOCIATION DEMO ---
    # Student and Professor know about each other without ownership
    student_alice = Student("S-9001", "Alice Hopper", 3.95)
    student_alice.assign_advisor(prof_knuth)

    # --- 4. DEPENDENCY DEMO ---
    # TranscriptPrinter temporarily processes student_alice
    TranscriptPrinter.print_transcript(student_alice)

    # --- LIFECYCLE CHECK ---
    print("Checking Lifecycles:")
    print(f"  • Deleting University instance '{mit.name}'...")
    del mit
    # 'mit' is gone, but prof_knuth still exists in memory!
    print(f"  ✓ Professor {prof_knuth.name} still exists independently: {prof_knuth}")

Step 3: Run & Verify

uv run university_system.py

Output Summary

📚 [Aggregation] Donald Knuth joined the Computer Science Department
📚 [Aggregation] Leonhard Euler joined the Mathematics Department

🏛️  University: Massachusetts Institute of Technology
--------------------------------------------------
  🏢 Department: Computer Science
     └─ Faculty: Prof. Donald Knuth (Algorithms)
  🏢 Department: Mathematics
     └─ Faculty: Prof. Leonhard Euler (Number Theory)
  🏢 Department: Physics
     └─ Faculty: [No staff assigned]

🤝 [Association] Alice Hopper is now advised by Donald Knuth

==================================================
          OFFICIAL TRANSCRIPT: ALICE HOPPER     
==================================================
 Student ID : S-9001
 Current GPA: 3.95
 Advisor    : Donald Knuth
--------------------------------------------------

Checking Lifecycles:
  • Deleting University instance 'Massachusetts Institute of Technology'...
  ✓ Professor Donald Knuth still exists independently: Prof. Donald Knuth (Algorithms)

#03 – The Power of Reuse: Inheritance & Polymorphism in Python

Thiruvengadam Sakthivel — Fri, 24 Jul 2026 05:35:12 +0000

Welcome to Day 3! Today we explore how classes share, extend, and adapt behavior without duplicating code.

Inheritance: Creating new classes based on existing ones to reuse code and establish hierarchies.
Method Overriding & super(): Redefining parent class behaviors in child classes while retaining access to parent implementations.
Polymorphism & Duck Typing: Operating on different object types through a shared interface or common set of methods.

1. Inheritance Structures 🌳

Python supports three primary flavors of inheritance:

  SINGLE INHERITANCE         MULTILEVEL INHERITANCE        MULTIPLE INHERITANCE

     ┌──────────┐                 ┌──────────┐           ┌───────┐   ┌─────────┐
     │  Parent  │                 │  Grandpa │           │ Mixin │   │ BaseClass│
     └────┬─────┘                 └────┬─────┘           └───┬───┘   └───┬─────┘
          │                            │                     │           │
          ▼                            ▼                     └─────┬─────┘
     ┌──────────┐                 ┌──────────┐                     ▼
     │  Child   │                 │  Parent  │               ┌───────────┐
     └──────────┘                 └────┬─────┘               │   Child   │
                                       │                     └───────────┘
                                       ▼
                                  ┌──────────┐
                                  │  Child   │
                                  └──────────┘

Single Inheritance: One child class inherits from one direct parent class.
Multilevel Inheritance: A child class inherits from a parent class, which itself inherits from a grandparent class (a chain).
Multiple Inheritance: A single child class inherits directly from two or more parent classes.

2. Method Overriding & `super()` 🔄

Method Overriding: Occurs when a child class defines a method with the exact same name as a method in its parent class. The child's method replaces or modifies the parent behavior.
super(): A built-in function that lets you invoke methods from a parent class inside the child class. This prevents code repetition when extending parent functionality.

🌱 Quick Example

class Animal:
    def __init__(self, name: str):
        self.name = name

    def make_sound(self) -> str:
        return "Generic animal sound"

class Dog(Animal):
    def __init__(self, name: str, breed: str):
        # Call parent constructor using super()
        super().__init__(name)
        self.breed = breed

    # Override parent method
    def make_sound(self) -> str:
        parent_sound = super().make_sound()
        return f"{parent_sound} -> Woof! 🐾"

dog = Dog("Rex", "German Shepherd")
print(dog.make_sound())  # Output: Generic animal sound -> Woof! 🐾

3. Polymorphism & Duck Typing 🦆

Polymorphism ("many shapes") allows different classes to respond to the same method call in their own unique way.

In Python, polymorphism is heavily tied to Duck Typing:

"If it walks like a duck and quacks like a duck, it's a duck."

Python doesn't care about explicit class hierarchies or explicit interface contracts—if an object implements the expected method (e.g., .calculate_pay()), Python will happily execute it.

                     ┌───────────────────────────────┐
                     │   Payroll Processor Service   │
                     └───────────────┬───────────────┘
                                     │
                      Calls .calculate_pay() on each
                                     │
      ┌──────────────────────────────┼──────────────────────────────┐
      ▼                              ▼                              ▼
┌──────────┐                   ┌──────────┐                   ┌──────────┐
│ FullTime │                   │ Executive│                   │Contractor│
│ Employee │                   │ Manager  │                   │ (No Base)│
└──────────┘                   └──────────┘                   └──────────┘

4. Practice Challenge: Building an Employee Management System 🏢

Here is a enterprise-ready Employee Management System demonstrating Single, Multilevel, and Multiple Inheritance, Method Overriding with super(), and Duck Typing via a unified PayrollProcessor.

Step 1: Initialize Your Workspace

uv init oop_day3 && cd oop_day3
touch employee_system.py

Step 2: Implement `employee_system.py`

# employee_system.py
from typing import List, Any


# ==========================================
# 1. BASE CLASS (PARENT)
# ==========================================
class Employee:
    """Base class for all salaried employees."""

    def __init__(self, emp_id: str, name: str, base_salary: float):
        self.emp_id = emp_id
        self.name = name
        self.base_salary = base_salary

    def calculate_pay(self) -> float:
        """Calculates standard monthly pay."""
        return round(self.base_salary, 2)

    def get_details(self) -> str:
        return f"[{self.emp_id}] {self.name} | Role: Employee | Base Salary: ${self.base_salary:,.2f}"


# ==========================================
# 2. SINGLE INHERITANCE: DEVELOPER
# ==========================================
class Developer(Employee):
    """Inherits directly from Employee (Single Inheritance)."""

    def __init__(self, emp_id: str, name: str, base_salary: float, tech_stack: str):
        super().__init__(emp_id, name, base_salary)
        self.tech_stack = tech_stack

    # Override calculate_pay to add a tech allowance
    def calculate_pay(self) -> float:
        tech_bonus = 300.00  # Fixed monthly tooling stipend
        return round(super().calculate_pay() + tech_bonus, 2)

    def get_details(self) -> str:
        return f"[{self.emp_id}] {self.name} | Role: Developer ({self.tech_stack})"


# ==========================================
# 3. MULTILEVEL INHERITANCE: MANAGER -> EXECUTIVE
# ==========================================
class Manager(Employee):
    """Inherits from Employee (Level 1)."""

    def __init__(self, emp_id: str, name: str, base_salary: float, team_size: int):
        super().__init__(emp_id, name, base_salary)
        self.team_size = team_size

    def calculate_pay(self) -> float:
        team_allowance = self.team_size * 150.00
        return round(super().calculate_pay() + team_allowance, 2)

    def get_details(self) -> str:
        return f"[{self.emp_id}] {self.name} | Role: Manager | Team Size: {self.team_size}"


class Executive(Manager):
    """Inherits from Manager (Level 2 - Multilevel Inheritance: Employee -> Manager -> Executive)."""

    def __init__(self, emp_id: str, name: str, base_salary: float, team_size: int, stock_options: int):
        super().__init__(emp_id, name, base_salary, team_size)
        self.stock_options = stock_options

    def calculate_pay(self) -> float:
        executive_bonus = 2500.00
        # Combines base salary + team allowance (from Manager) + executive bonus
        return round(super().calculate_pay() + executive_bonus, 2)

    def get_details(self) -> str:
        return f"[{self.emp_id}] {self.name} | Role: Executive | Options: {self.stock_options} units"


# ==========================================
# 4. MULTIPLE INHERITANCE / MIXIN: AUDITABLE
# ==========================================
class ComplianceAuditableMixin:
    """A standalone mixin class that adds auditing capabilities."""

    def log_audit(self, action: str) -> None:
        print(f"[AUDIT LOG] Entity Action Recorded: '{action}'")


class TechLead(Developer, ComplianceAuditableMixin):
    """Inherits from Developer AND ComplianceAuditableMixin (Multiple Inheritance)."""

    def __init__(self, emp_id: str, name: str, base_salary: float, tech_stack: str, projects_count: int):
        Developer.__init__(self, emp_id, name, base_salary, tech_stack)
        self.projects_count = projects_count

    def get_details(self) -> str:
        return f"[{self.emp_id}] {self.name} | Role: Tech Lead | Projects: {self.projects_count}"


# ==========================================
# 5. DUCK TYPING: CONTRACTOR (NO BASE CLASS)
# ==========================================
class ExternalContractor:
    """Does NOT inherit from Employee, but implements calculate_pay() and get_details()."""

    def __init__(self, contractor_id: str, name: str, hourly_rate: float, hours_worked: float):
        self.contractor_id = contractor_id
        self.name = name
        self.hourly_rate = hourly_rate
        self.hours_worked = hours_worked

    def calculate_pay(self) -> float:
        return round(self.hourly_rate * self.hours_worked, 2)

    def get_details(self) -> str:
        return f"[{self.contractor_id}] {self.name} | External Contractor ({self.hours_worked} hrs @ ${self.hourly_rate}/hr)"


# ==========================================
# 6. UNIFIED PAYROLL PROCESSOR (POLYMORPHISM)
# ==========================================
class PayrollProcessor:
    """Uses Polymorphism & Duck Typing to process pay across any compatible worker object."""

    @staticmethod
    def process_payroll(workers: List[Any]) -> None:
        print("==========================================================")
        print("             MONTHLY PAYROLL REPORT                       ")
        print("==========================================================")
        total_payout = 0.0

        for worker in workers:
            # Duck typing in action: as long as worker has get_details() and calculate_pay(), it works
            details = worker.get_details()
            pay = worker.calculate_pay()
            total_payout += pay
            print(f"{details}\n  └─ Calculated Payout: ${pay:,.2f}\n")

        print("----------------------------------------------------------")
        print(f" TOTAL SYSTEM PAYOUT: ${total_payout:,.2f}")
        print("==========================================================\n")


# ==========================================
# TEST EXECUTION SUITE
# ==========================================
if __name__ == "__main__":
    # Create instances across various inheritance patterns
    dev = Developer("EMP-101", "Alice Chen", base_salary=7500.00, tech_stack="Python/FastAPI")
    mgr = Manager("EMP-102", "Bob Smith", base_salary=9000.00, team_size=5)
    exec_officer = Executive("EMP-103", "Carol Danvers", base_salary=15000.00, team_size=20, stock_options=5000)

    # Multiple Inheritance instance
    tech_lead = TechLead("EMP-104", "David Miller", base_salary=11000.00, tech_stack="Distributed Systems", projects_count=3)
    tech_lead.log_audit("Approved Architecture Review")  # Mixin functionality

    # Duck Typing instance (No inheritance from Employee class)
    contractor = ExternalContractor("CONT-801", "Eva Green", hourly_rate=85.00, hours_worked=120)

    # Heterogeneous collection passed into PayrollProcessor
    workforce = [dev, mgr, exec_officer, tech_lead, contractor]

    # Run Polymorphic Payroll
    PayrollProcessor.process_payroll(workforce)

Step 3: Run & Verify Execution

uv run employee_system.py

Output Summary

[AUDIT LOG] Entity Action Recorded: 'Approved Architecture Review'

==========================================================
             MONTHLY PAYROLL REPORT                       
==========================================================
[EMP-101] Alice Chen | Role: Developer (Python/FastAPI)
  └─ Calculated Payout: $7,800.00

[EMP-102] Bob Smith | Role: Manager | Team Size: 5
  └─ Calculated Payout: $9,750.00

[EMP-103] Carol Danvers | Role: Executive | Options: 5000 units
  └─ Calculated Payout: $20,500.00

[EMP-104] David Miller | Role: Tech Lead | Projects: 3
  └─ Calculated Payout: $11,300.00

[CONT-801] Eva Green | External Contractor (120 hrs @ $85.0/hr)
  └─ Calculated Payout: $10,200.00

----------------------------------------------------------
 TOTAL SYSTEM PAYOUT: $59,550.00
==========================================================

#02 – Hiding Complexity: Encapsulation & Abstraction in Python

Thiruvengadam Sakthivel — Wed, 22 Jul 2026 15:33:49 +0000

Welcome to Day 2! Today we focus on two core pillars of Object-Oriented Programming:

Encapsulation: Hiding internal state and requiring all interaction to go through performing validation or controlled methods.
Abstraction: Hiding complex implementation details and exposing only a clean, simplified interface to the user.

1. Access Modifiers: Public, Protected, & Private 🛡️

Python does not have strict enforcement keywords like public or private found in Java or C++. Instead, it uses naming conventions and name mangling to communicate intent and protect internal data.

┌─────────────────────────────────────────────────────────────────────────────┐
│                          ACCESS MODIFIERS IN PYTHON                         │
├──────────────┬───────────────┬──────────────────────────────────────────────┤
│ Level        │ Syntax        │ Scope / Intended Access                      │
├──────────────┼───────────────┼──────────────────────────────────────────────┤
│ Public       │ self.name     │ Accessible anywhere (inside & outside class) │
│ Protected    │ self._balance │ Internal & subclasses only (Convention)      │
│ Private      │ self.__pin    │ Class internal only (Triggers Name Mangling) │
└──────────────┴───────────────┴──────────────────────────────────────────────┘

Public (self.name): Fully accessible from anywhere.
Protected (self._balance): Single leading underscore. Signals to developers: "This is internal—do not mutate or access outside this class or its subclasses."
Private (self.__pin): Double leading underscore. Triggers name mangling (_ClassName__attribute), making it hard to accidentally access or override outside the class.

💻 Code Example: Access Modifiers & Name Mangling

class SecureVault:
    def __init__(self, owner: str, balance: float, pin_code: str):
        self.owner = owner          # Public
        self._balance = balance      # Protected (convention)
        self.__pin = pin_code        # Private (name mangled)

    def verify_pin(self, pin: str) -> bool:
        return self.__pin == pin

vault = SecureVault("Alice", 50000.0, "9876")

# Public access works as expected
print(vault.owner)        # Output: Alice

# Protected access works, but violates Python conventions
print(vault._balance)     # Output: 50000.0

# Private access raises an AttributeError directly
try:
    print(vault.__pin)
except AttributeError as e:
    print("Direct private access blocked:", e)

# Accessing private attribute via Python's name-mangled name
print("Mangled PIN access:", vault._SecureVault__pin)  # Output: 9876

2. Getters & Setters (`@property`) ⚙️

Instead of writing verbose Java-style methods like get_balance() and set_balance(), Python provides the @property decorator. It allows you to access methods like regular attributes while giving you full control over validation, read-only constraints, and dynamic computation.

       GETTER                                     SETTER
  user.balance ───────► [@property] ───────► Returns internal self._balance
                             │
  user.balance = 100 ────────┴──────────────► [@balance.setter] ──► Validates > 0

💻 Code Example: Controlled Access with `@property`

class BankAccount:
    def __init__(self, owner: str, initial_balance: float):
        self.owner = owner
        self._balance = initial_balance  # Internal state

    # Getter: Exposes balance as a read-only property
    @property
    def balance(self) -> float:
        return round(self._balance, 2)

    # Setter: Validates new values before updating balance
    @balance.setter
    def balance(self, value: float) -> None:
        if value < 0:
            raise ValueError("Balance cannot be negative.")
        print(f"Balance updated from ${self._balance:.2f} to ${value:.2f}")
        self._balance = value

acc = BankAccount("Charlie", 250.00)

# Calls the getter (looks like an attribute)
print(f"Current Balance: ${acc.balance}")

# Calls the setter (validates input)
acc.balance = 300.00  # Output: Balance updated from $250.00 to $300.00

# Invalid update throws an error
try:
    acc.balance = -50.00
except ValueError as err:
    print("Validation Error:", err)  # Output: Balance cannot be negative.

3. Abstraction & Abstract Base Classes (`abc`) 🎨

Abstraction means hiding complex underlying details and only defining the contract (methods) that a class must provide.

Python achieves abstraction using the abc module (Abstract Base Classes) and the @abstractmethod decorator:

An Abstract Class cannot be instantiated directly.
Any concrete subclass must implement all @abstractmethod definitions, or Python will raise an error at instantiation time.

                       ┌────────────────────────────────┐
                       │  «Abstract Base Class»         │
                       │  PaymentProcessor              │
                       ├────────────────────────────────┤
                       │  + process_payment(amount)     │
                       │  + refund_payment(txn_id)      │
                       └───────────────┬────────────────┘
                                       │
            ┌──────────────────────────┼──────────────────────────┐
            ▼                          ▼                          ▼
┌───────────────────────┐  ┌───────────────────────┐  ┌───────────────────────┐
│ CreditCardProcessor   │  │ PayPalProcessor       │  │ CryptoProcessor       │
├───────────────────────┤  ├───────────────────────┤  ├───────────────────────┤
│ Implements methods    │  │ Implements methods    │  │ Implements methods    │
└───────────────────────┘  └───────────────────────┘  └───────────────────────┘

4. Practice Challenge: Design a Payment System 💳

Here is a enterprise-ready payment system architecture built with abstract base classes, private encapsulation, and input validation properties.

Step 1: Initialize Your Workspace

uv init oop_day2 && cd oop_day2
touch payment_system.py

Step 2: Implement `payment_system.py`

# payment_system.py
from abc import ABC, abstractmethod
from typing import Dict, Any
import uuid


# ==========================================
# 1. ABSTRACT BASE CLASS (INTERFACE CONTRACT)
# ==========================================
class PaymentProcessor(ABC):
    """Abstract base class establishing the contract for all payment gateways."""

    def __init__(self, provider_name: str):
        self.provider_name = provider_name

    @abstractmethod
    def process_payment(self, amount: float) -> Dict[str, Any]:
        """Processes a payment transaction. Must be overridden by subclasses."""
        pass

    @abstractmethod
    def refund_payment(self, transaction_id: str, amount: float) -> bool:
        """Refunds a previous transaction. Must be overridden by subclasses."""
        pass


# ==========================================
# 2. CONCRETE IMPLEMENTATION: CREDIT CARD
# ==========================================
class CreditCardProcessor(PaymentProcessor):
    def __init__(self, merchant_id: str, api_key: str):
        super().__init__("Credit Card Gateway")
        self.merchant_id = merchant_id
        self.__api_key = api_key  # Private API key

    def process_payment(self, amount: float) -> Dict[str, Any]:
        if amount <= 0:
            return {"success": False, "error": "Invalid payment amount."}

        txn_id = f"CC-{uuid.uuid4().hex[:8].upper()}"
        print(f"[{self.provider_name}] Processing ${amount:.2f} via Merchant ID: {self.merchant_id}...")

        return {
            "success": True,
            "transaction_id": txn_id,
            "amount": amount,
            "provider": self.provider_name
        }

    def refund_payment(self, transaction_id: str, amount: float) -> bool:
        print(f"[{self.provider_name}] Refunding ${amount:.2f} on Transaction #{transaction_id}...")
        return True


# ==========================================
# 3. CONCRETE IMPLEMENTATION: PAYPAL
# ==========================================
class PayPalProcessor(PaymentProcessor):
    def __init__(self, client_email: str):
        super().__init__("PayPal System")
        self._client_email = client_email  # Protected attribute

    def process_payment(self, amount: float) -> Dict[str, Any]:
        if amount <= 0:
            return {"success": False, "error": "Invalid payment amount."}

        txn_id = f"PP-{uuid.uuid4().hex[:8].upper()}"
        print(f"[{self.provider_name}] Charging ${amount:.2f} to account {self._client_email}...")

        return {
            "success": True,
            "transaction_id": txn_id,
            "amount": amount,
            "provider": self.provider_name
        }

    def refund_payment(self, transaction_id: str, amount: float) -> bool:
        print(f"[{self.provider_name}] Issuing PayPal refund for ${amount:.2f} to {self._client_email}...")
        return True


# ==========================================
# 4. UNIFIED PAYMENT SERVICE (ABSTRACTION IN ACTION)
# ==========================================
class CheckoutService:
    """Consumes any PaymentProcessor through abstraction without knowing inner mechanics."""

    def __init__(self, processor: PaymentProcessor):
        self.processor = processor

    def checkout(self, amount: float) -> None:
        print("\n--- Initiating Checkout ---")
        result = self.processor.process_payment(amount)

        if result["success"]:
            print(f"✓ Checkout Successful! Txn ID: {result['transaction_id']}")
        else:
            print(f"✗ Checkout Failed: {result.get('error')}")


# ==========================================
# TEST EXECUTION SUITE
# ==========================================
if __name__ == "__main__":
    # Attempting to instantiate abstract class raises TypeError
    try:
        base = PaymentProcessor("Generic")
    except TypeError as err:
        print("Abstract Class Guard Working:")
        print(f"  --> {err}\n")

    # Instantiate concrete processors
    cc_gateway = CreditCardProcessor(merchant_id="MERCH-8821", api_key="secret_live_key")
    paypal_gateway = PayPalProcessor(client_email="billing@corporate.org")

    # Process transactions dynamically via CheckoutService
    cart_1 = CheckoutService(cc_gateway)
    cart_1.checkout(149.99)

    cart_2 = CheckoutService(paypal_gateway)
    cart_2.checkout(89.50)

    # Trigger a refund
    cc_gateway.refund_payment("CC-9A2F1B0C", 149.99)

Step 3: Run & Verify

uv run payment_system.py

Output Summary

Abstract Class Guard Working:
  --> Can't instantiate abstract class PaymentProcessor without an implementation for abstract methods 'process_payment', 'refund_payment'


--- Initiating Checkout ---
[Credit Card Gateway] Processing $149.99 via Merchant ID: MERCH-8821...
✓ Checkout Successful! Txn ID: CC-7B9F10A2

--- Initiating Checkout ---
[PayPal System] Charging $89.50 to account billing@corporate.org...
✓ Checkout Successful! Txn ID: PP-3E41D8B9

[Credit Card Gateway] Refunding $149.99 on Transaction #CC-9A2F1B0C...

#01 – The Blueprint of Everything: Classes & Objects in Python

Thiruvengadam Sakthivel — Tue, 21 Jul 2026 13:40:39 +0000

Welcome to Object-Oriented Programming (OOP) in Python! Up until now, we’ve handled data using individual variables, functions, and collections. OOP allows you to bundle related data (attributes) and behaviors (methods) together into clean, reusable custom types. 🧩

1. Classes, Objects, `init`, & `self` 🏛️

Class: The blueprint or template for creating objects (e.g., the architectural plan for a house).
Object (Instance): The concrete entity created in memory from that blueprint (e.g., the actual house built on a specific lot).
__init__ Method: A special method (constructor) that Python runs automatically whenever you instantiate a new object to set up its starting state.
self Keyword: A reference pointing directly to the current instance of the class, allowing methods to access and modify that specific object's data.

┌─────────────────────────────────────────────────────────────────┐
│                          CLASS BLUEPRINT                        │
│                     class User(name, email)                     │
└────────────────────────────────┬────────────────────────────────┘
                                 │
                   Instantiates (Creates Instances)
                                 │
            ┌────────────────────┴────────────────────┐
            ▼                                         ▼
┌─────────────────────────┐               ┌─────────────────────────┐
│    OBJECT INSTANCE #1   │               │    OBJECT INSTANCE #2   │
│  name: "Alice"          │               │  name: "Bob"            │
│  email: "alice@dev.com" │               │  email: "bob@dev.com"   │
└─────────────────────────┘               └─────────────────────────┘

🌱 Easy Starter Example

class Dog:
    # Constructor method initializing instance state
    def __init__(self, name: str, breed: str):
        self.name = name    # Store name on this specific instance
        self.breed = breed  # Store breed on this specific instance

    # Instance method
    def bark(self) -> None:
        print(f"{self.name} says: Woof! 🐾")

# Instantiating two distinct objects from the Dog class
dog1 = Dog("Buddy", "Golden Retriever")
dog2 = Dog("Luna", "Border Collie")

dog1.bark()  # Output: Buddy says: Woof! 🐾
dog2.bark()  # Output: Luna says: Woof! 🐾

🏛️ Real-World Example: User Session Identity Manager

from datetime import datetime

class UserSession:
    def __init__(self, username: str, role: str = "member"):
        self.username = username
        self.role = role
        self.login_time = datetime.now()
        self.is_authenticated = True

    def logout(self) -> None:
        self.is_authenticated = False
        print(f"Session terminated for user '{self.username}'.")

    def get_status(self) -> str:
        status = "Active" if self.is_authenticated else "Logged Out"
        return f"[{self.username}] Role: {self.role} | Status: {status}"

# Usage
session_alex = UserSession("alex_dev", role="admin")
print(session_alex.get_status())  # Output: [alex_dev] Role: admin | Status: Active
session_alex.logout()             # Output: Session terminated for user 'alex_dev'.

2. Instance vs. Class Attributes ⚙️

Attributes define the state of your data, but they live in two distinct scopes:

Attribute Type	Where It Is Defined	Scope & Behavior
Instance Attribute	Inside `__init__` using `self.variable`	Unique to each individual object. Modifying it on one instance does not affect others.
Class Attribute	Directly inside the class body, outside methods	Shared across all instances of the class. Useful for constants or global defaults.

┌─────────────────────────────────────────────────────────────────┐
│                      CLASS: CommercialProduct                   │
│  default_tax_rate = 0.08  ◄─── (CLASS ATTRIBUTE: Shared by all) │
└────────────────────────────────┬────────────────────────────────┘
                                 │
             ┌───────────────────┴───────────────────┐
             ▼                                       ▼
┌─────────────────────────┐             ┌─────────────────────────┐
│   INSTANCE A (Item A)   │             │   INSTANCE B (Item B)   │
│  name: "Headphones"     │             │  name: "Keyboard"       │
│  base_price: 100.00     │             │  base_price: 150.00     │
└─────────────────────────┘             └─────────────────────────┘
 (INSTANCE ATTRIBUTES: Unique per instance)

🌱 Easy Starter Example

class Employee:
    # Class Attribute (shared across all employee instances)
    company_name = "TechCorp Global"

    def __init__(self, name: str, salary: float):
        # Instance Attributes (unique to each employee)
        self.name = name
        self.salary = salary

emp1 = Employee("Alice", 85000)
emp2 = Employee("Bob", 92000)

print(emp1.company_name)  # Output: TechCorp Global
print(emp2.company_name)  # Output: TechCorp Global

# Changing the class attribute updates it for ALL instances
Employee.company_name = "TechCorp AI Solutions"
print(emp1.company_name)  # Output: TechCorp AI Solutions

🏛️ Real-World Example: Product Pricing Engine with Tax Rates

class CommercialProduct:
    # Class attribute: Standard VAT/Sales tax applied across all product lines
    default_tax_rate: float = 0.08  # 8% tax

    def __init__(self, product_id: str, name: str, base_price: float):
        self.product_id = product_id
        self.name = name
        self.base_price = base_price

    def calculate_final_price(self) -> float:
        """Computes price including the class-level tax rate."""
        final_price = self.base_price * (1.0 + CommercialProduct.default_tax_rate)
        return round(final_price, 2)

item_a = CommercialProduct("SKU-101", "Wireless Headphones", 100.00)
print(f"Price for {item_a.name}: ${item_a.calculate_final_price()}")  # Output: $108.0

# Adjust regional tax rate globally across all products
CommercialProduct.default_tax_rate = 0.10  # Updated to 10%
print(f"Updated price for {item_a.name}: ${item_a.calculate_final_price()}")  # Output: $110.0

3. Practice Challenge: Building User, Product, & BankAccount Classes 🏋️

Here is a clean, modular Python script containing three core domain classes: User, Product, and BankAccount.

Step 1: Initialize Your Workspace

Inside your terminal workspace:

uv init oop_day1 && cd oop_day1
touch domain_models.py

Step 2: Implement `domain_models.py`

Open domain_models.py and add the three complete class implementations:

# domain_models.py
from datetime import datetime


# ==========================================
# 1. USER CLASS
# ==========================================
class User:
    """Represents an application user profile."""

    def __init__(self, username: str, email: str, role: str = "member"):
        self.username = username
        self.email = email
        self.role = role
        self.is_active: bool = True
        self.created_at: datetime = datetime.now()

    def deactivate(self) -> None:
        """Deactivates the user account."""
        self.is_active = False
        print(f"User '{self.username}' account has been deactivated.")

    def activate(self) -> None:
        """Activates the user account."""
        self.is_active = True
        print(f"User '{self.username}' account is now active.")

    def get_summary(self) -> str:
        status = "Active" if self.is_active else "Inactive"
        return f"User: {self.username} | Email: {self.email} | Role: {self.role} | Status: {status}"


# ==========================================
# 2. PRODUCT CLASS
# ==========================================
class Product:
    """Represents an e-commerce product catalog item."""

    # Class attribute: Shared tax rate across all inventory items
    category_tax_rate: float = 0.07  # 7% standard tax

    def __init__(self, product_id: str, name: str, price: float, stock_quantity: int = 0):
        self.product_id = product_id
        self.name = name
        self.price = price
        self.stock_quantity = stock_quantity

    def apply_discount(self, percentage: float) -> None:
        """Reduces the base product price by a percentage (e.g., 15 for 15%)."""
        if 0 < percentage < 100:
            discount_amount = self.price * (percentage / 100)
            self.price -= discount_amount
            print(f"Applied {percentage}% discount to {self.name}. New Price: ${self.price:.2f}")
        else:
            print("Invalid discount percentage specified.")

    def restock(self, amount: int) -> None:
        """Increases the inventory count."""
        if amount > 0:
            self.stock_quantity += amount
            print(f"Restocked {amount} units of '{self.name}'. Total Stock: {self.stock_quantity}")

    def get_total_price_with_tax(self) -> float:
        """Calculates total unit price including tax."""
        total = self.price * (1.0 + Product.category_tax_rate)
        return round(total, 2)


# ==========================================
# 3. BANK ACCOUNT CLASS
# ==========================================
class BankAccount:
    """Simulates a financial bank account with transaction guards."""

    # Class attribute: Track total accounts created system-wide
    total_accounts_opened: int = 0

    def __init__(self, account_number: str, owner_name: str, initial_balance: float = 0.0):
        self.account_number = account_number
        self.owner_name = owner_name
        self.balance = initial_balance

        # Increment global account counter when an instance is created
        BankAccount.total_accounts_opened += 1

    def deposit(self, amount: float) -> float:
        """Deposits funds into the account balance."""
        if amount <= 0:
            print("Deposit amount must be greater than $0.00.")
            return self.balance

        self.balance += amount
        print(f"[+] Deposited ${amount:.2f} into account {self.account_number}. Current Balance: ${self.balance:.2f}")
        return self.balance

    def withdraw(self, amount: float) -> float:
        """Withdraws funds with overdraft protection checks."""
        if amount <= 0:
            print("Withdrawal amount must be greater than $0.00.")
            return self.balance

        if amount > self.balance:
            print(f"[!] Transaction Declined: Insufficient funds on account {self.account_number}. Available: ${self.balance:.2f}")
            return self.balance

        self.balance -= amount
        print(f"[-] Withdrew ${amount:.2f} from account {self.account_number}. Remaining Balance: ${self.balance:.2f}")
        return self.balance

    def get_statement(self) -> str:
        return f"Account #{self.account_number} ({self.owner_name}) - Current Balance: ${self.balance:.2f}"


# ==========================================
# TEST EXECUTION SUITE
# ==========================================
if __name__ == "__main__":
    print("--- 1. Testing User Class ---")
    user1 = User("sara_m", "sara@company.org", role="Admin")
    print(user1.get_summary())
    user1.deactivate()
    print(user1.get_summary())

    print("\n--- 2. Testing Product Class ---")
    laptop = Product("SKU-902", "Developer Laptop", price=1200.00, stock_quantity=10)
    print(f"Base Price: ${laptop.price:.2f} | Total with Tax: ${laptop.get_total_price_with_tax():.2f}")
    laptop.apply_discount(10)  # 10% off
    laptop.restock(5)

    print("\n--- 3. Testing BankAccount Class ---")
    acc1 = BankAccount("ACC-001", "Sara Miller", initial_balance=500.00)
    acc2 = BankAccount("ACC-002", "John Doe", initial_balance=100.00)

    acc1.deposit(250.00)
    acc1.withdraw(100.00)
    acc1.withdraw(1000.00)  # Should trigger overdraft warning

    print(f"\nTotal Bank Accounts Active: {BankAccount.total_accounts_opened}")

Step 3: Run & Verify Execution

Run the script using your terminal:

uv run domain_models.py

Output Summary

--- 1. Testing User Class ---
User: sara_m | Email: sara@company.org | Role: Admin | Status: Active
User 'sara_m' account has been deactivated.
User: sara_m | Email: sara@company.org | Role: Admin | Status: Inactive

--- 2. Testing Product Class ---
Base Price: $1200.00 | Total with Tax: $1284.00
Applied 10.0% discount to Developer Laptop. New Price: $1080.00
Restocked 5 units of 'Developer Laptop'. Total Stock: 15

--- 3. Testing BankAccount Class ---
[+] Deposited $250.00 into account ACC-001. Current Balance: $750.00
[-] Withdrew $100.00 from account ACC-001. Remaining Balance: $650.00
[!] Transaction Declined: Insufficient funds on account ACC-001. Available: $650.00

Total Bank Accounts Active: 2

#07 – Pythonic Code & Standard Library

Thiruvengadam Sakthivel — Sun, 19 Jul 2026 03:40:46 +0000

Welcome to Day 7! Today, we bridge the gap between just writing code that works and writing code that is Pythonic—meaning elegant, maintainable, performant, and aligned with industry standards. We will dive deep into Python’s built-in standard library utilities, explore type systems, and introduce the professional toolchain used to test and format production-grade software. 🏎️

1. Writing Pythonic Code & Type Hints 🐍

Writing "Pythonic" code means prioritizing readability and simplicity, following PEP 8 (Python's official style guide), and documenting intentions cleanly.

Type Hints & Modern Typing

Type hints make your code predictable. They don't enforce types at runtime, but they allow IDEs and checkers (like mypy) to catch data bugs before your code even runs.

Optional[T] / T | None: Indicates a value can either be of type T or None.
Union[A, B] / A | B: Indicates a value can be type A or type B.
Literal[...]: Restricts a variable to specific, exact values.
TypedDict: Defines a dictionary with a fixed set of string keys and specific value types.
Callable[[Args], Return]: Declares that a parameter expects a executable function.

from typing import TypedDict, Literal, Callable

# 1. Defining structural dictionaries with TypedDict
class UserSession(TypedDict):
    username: str
    role: Literal["admin", "moderator", "guest"]  # Restricts values to these strings
    session_id: int | None                         # Modern Union/Optional shorthand

# 2. Using Callable and Type Hints in functions
def execute_transaction(user: UserSession, callback: Callable[[str], bool]) -> str:
    """Processes a user session and triggers a callback verification hook.

    Args:
        user: A UserSession TypedDict configuration map.
        callback: A function taking a string and returning a boolean status.
    """
    if user["session_id"] is None:
        return "Transaction Aborted: Invalid Session."

    success = callback(user["username"])
    return "Complete" if success else "Failed"

2. Standard Library Powerhouses 🧰

Python comes with built-in modules designed to eliminate boilerplate code. Let's look at three essential modules: collections, itertools, and functools.

A. The `collections` Module

Optimized container data types that go far beyond standard lists and dictionaries.

Tool	Core Problem It Solves	Fast Example
`Counter`	Counting occurrences of elements instantly.	`Counter("apple")` $\rightarrow$ `{'p': 2, 'a': 1, ...}`
`defaultdict`	Eliminates `KeyError` by providing default values automatically.	`defaultdict(list)` appends rows without checking if key exists.
`deque`	Double-ended queues with fast $O(1)$ appends/pops on both ends.	`deque(maxlen=3)` maintains a rolling log of elements.
`namedtuple`	Quick, lightweight, immutable data objects.	`Point = namedtuple('Point', ['x', 'y'])`

from collections import Counter, defaultdict, deque

# Quick Counter usage
item_counts = Counter(["apple", "banana", "apple", "orange", "banana", "apple"])
print(item_counts.most_common(1))  # Output: [('apple', 3)]

# Rolling logs with deque
recent_actions = deque(maxlen=3)
for action in ["login", "view_page", "click_cart", "checkout"]:
    recent_actions.append(action)
print(recent_actions)  # Output: deque(['view_page', 'click_cart', 'checkout'], maxlen=3)

B. The `itertools` Module

A toolkit of memory-efficient streaming iterators for handling complex loop structures.

chain: Glues multiple iterables together into a single continuous stream.
combinations / permutations: Generates mathematical arrangements without nested loops.
groupby: Groups contiguous elements in a dataset sharing a common key (Note: Data must be sorted by the grouping key first!).

import itertools

# Chaining multiple lists cleanly
combined = list(itertools.chain([1, 2], [3, 4], [5])) # Output: [1, 2, 3, 4, 5]

# Unique pairs combinations
pairs = list(itertools.combinations(["A", "B", "C"], 2))
print(pairs)  # Output: [('A', 'B'), ('A', 'C'), ('B', 'C')]

# Grouping sorted elements
data = [("Admin", "Alice"), ("Admin", "Bob"), ("Dev", "Charlie")]
for role, group in itertools.groupby(data, key=lambda x: x[0]):
    print(f"{role}: {list(group)}")

C. The `functools` Module

Higher-order tools designed to modify or optimize how functions execute.

partial: Freezes a subset of a function's arguments to create a simpler version of it.
reduce: Repeatedly applies a function to a sequence to boil it down to a single value.
lru_cache: Adds memoization (caching function results based on inputs) to save time on heavy, repetitive computations.

from functools import partial, lru_cache

# 1. Freezing arguments with partial
def multiply(x, y): return x * y
double = partial(multiply, 2)
print(double(5))  # Output: 10

# 2. Caching heavy calculations with lru_cache
@lru_cache(maxsize=32)
def fibonacci(n: int) -> int:
    if n < 2: return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(35))  # Runs instantly instead of taking minutes!

3. Core System Utilities (Time, Paths & Constants) 🌍

A. Dates & Time Zones (`datetime`)

Always prefer timezone-aware datetimes when storing information to avoid offsets across servers.

from datetime import datetime, timezone

# Create a timezone-aware UTC timestamp
utc_now = datetime.now(timezone.utc)
print(utc_now)  # Output: 2026-07-19 03:37:50.123456+00:00

# Formatting to readable string
print(utc_now.strftime("%Y-%m-%d %H:%M:%S %Z"))

B. Advanced File Automation (`pathlib`)

pathlib can easily scan directories using patterns like wildcards (*) and recursive matches (**/*).

from pathlib import Path

# Scan the current directory for all python files matching a pattern
workspace = Path(".")
for py_file in workspace.rglob("*.py"):
    print(f"Found python source module: {py_file.name} ({py_file.stat().st_size} bytes)")

C. Readable Enumerations (`Enum`)

Enums turn vague string flags into clear, immutable code constants.

from enum import Enum, auto

class OrderStatus(Enum):
    PENDING = auto()
    PROCESSING = auto()
    SHIPPED = auto()
    DELIVERED = auto()

current_status = OrderStatus.PENDING
if current_status == OrderStatus.PENDING:
    print("Order is awaiting processing.")

4. Modern Development Workflow Tools 🛠️

Professional developers rely on tools to keep their code formatting uniform and verify that updates don't break existing features.

A. Ruff (The Modern Standard Linter & Formatter)

Written in Rust, Ruff replaces legacy tools like Black, Flake8, and isort—and runs up to 100x faster.

ruff check: Analyzes code for bugs, bad habits, and dead imports.
ruff format: Auto-formats code files to perfectly match PEP 8 guidelines.

B. Basics of `pytest`

pytest is the go-to testing framework for Python. To write a test, create a file named test_*.py and write functions that start with test_. Use standard assert statements to check your code's behavior.

# calculator.py
def add(a: int, b: int) -> int:
    return a + b

# test_calculator.py
from calculator import add

def test_add_combines_integers():
    assert add(3, 4) == 7
    assert add(-1, 1) == 0

Run your test suite directly from your terminal:

pytest test_calculator.py

5. Practice Challenge: E-Commerce Metrics Engine 🏋️

Let’s combine structural typing, collections, functools, Enum, pathlib, and pytest testing into a production-grade metrics engine.

Step 1: Initialize Your Workspace

uv init day_7_challenge && cd day_7_challenge
touch engine.py test_engine.py

Step 2: Implement the Main Business Logic

Open engine.py and write the processing engine:

# engine.py
from collections import Counter, defaultdict
from dataclasses import dataclass
from enum import Enum, auto
from functools import lru_cache
from typing import TypedDict

class Region(Enum):
    NORTH = auto()
    SOUTH = auto()
    EAST = auto()
    WEST = auto()

class RawOrderPayload(TypedDict):
    order_id: int
    item: str
    amount: float
    region: Region

@dataclass(frozen=True)
class AnalyticsReport:
    top_selling_item: str
    regional_spend: dict[Region, float]
    total_processed_orders: int

@lru_cache(maxsize=16)
def calculate_tax_rate(region: Region) -> float:
    """Simulates an intensive calculation to look up regional tax rates."""
    rates = {Region.NORTH: 0.05, Region.SOUTH: 0.07, Region.EAST: 0.06, Region.WEST: 0.08}
    return rates[region]

def process_market_orders(orders: list[RawOrderPayload]) -> AnalyticsReport:
    if not orders:
        return AnalyticsReport(top_selling_item="None", regional_spend={}, total_processed_orders=0)

    item_counter = Counter()
    spend_map = defaultdict(float)

    for order in orders:
        item = order["item"]
        region = order["region"]
        base_amount = order["amount"]

        # Calculate gross cost including regional tax adjustments
        tax_multiplier = 1.0 + calculate_tax_rate(region)
        gross_cost = base_amount * tax_multiplier

        item_counter[item] += 1
        spend_map[region] += round(gross_cost, 2)

    top_item = item_counter.most_common(1)[0][0]

    return AnalyticsReport(
        top_selling_item=top_item,
        regional_spend=dict(spend_map),
        total_processed_orders=len(orders)
    )

Step 3: Write Your Test Suite

Open test_engine.py to write your test assertions:

# test_engine.py
from engine import process_market_orders, Region, RawOrderPayload

def test_empty_order_list_returns_clean_report():
    report = process_market_orders([])
    assert report.total_processed_orders == 0
    assert report.top_selling_item == "None"

def test_metrics_calculation_pipeline():
    sample_orders: list[RawOrderPayload] = [
        {"order_id": 101, "item": "Laptop", "amount": 1000.00, "region": Region.NORTH},
        {"order_id": 102, "item": "Mouse", "amount": 50.00, "region": Region.NORTH},
        {"order_id": 103, "item": "Laptop", "amount": 1000.00, "region": Region.WEST},
    ]

    report = process_market_orders(sample_orders)

    # Assertions checking correctness
    assert report.total_processed_orders == 3
    assert report.top_selling_item == "Laptop"

    # North costs: (1000 + 50) * 1.05 = 1102.50
    assert report.regional_spend[Region.NORTH] == 1102.50

Step 4: Validate Code Style and Run Tests

Run the standard tools in your terminal to ensure everything is formatted correctly and passing:

# 1. Run the linter to check code health
uv run ruff check engine.py

# 2. Automatically apply formatting fixes
uv run ruff format engine.py test_engine.py

# 3. Execute the tests
uv run pytest test_engine.py

Outputs will confirm that the code matches professional standard guidelines and passes the logic assertions perfectly! 🏁

#06 – Advanced Python Features

Thiruvengadam Sakthivel — Sat, 18 Jul 2026 16:10:38 +0000

Welcome to Day 6! Today we are unlocking Python’s advanced feature set. We will cover writing concise expressions, managing custom streaming data loops, building clean code modifiers using decorators, managing temporary resources with context managers, and designing clean data structures using dataclasses. 🚀

1. Comprehensions 🧠

Comprehensions provide a concise syntax to derive new collections (lists, dictionaries, or sets) from existing iterables. They replace verbose for loops and execute faster because they run at C-speed inside the Python interpreter.

Advanced List Comprehensions: Supports filtering conditionals (if) and value transformations (if-else).
Dictionary Comprehensions: Dynamically generates key-value map structures ({k: v for ...}).
Set Comprehensions: Produces a unique collection of elements, automatically stripping duplicates ({x for ...}).

🌱 Easy Starter Example

# Advanced List Comprehension with if-else evaluation
numbers = [1, 2, 3, 4, 5, 6]
labels = ["Even" if x % 2 == 0 else "Odd" for x in numbers]
print(labels)  # Output: ['Odd', 'Even', 'Odd', 'Even', 'Odd', 'Even']

# Dictionary & Set Comprehensions
squared_dict = {x: x**2 for x in range(1, 4)}   # Output: {1: 1, 2: 4, 3: 9}
unique_lengths = {len(word) for word in ["apple", "banana", "apple"]} # Output: {5, 6}

🏛️ Real-World Example: HTTP API Response Sanitizer

def sanitize_api_payload(response_data: list[dict]) -> dict[str, dict]:
    # Extract unique active user identities using a Set Comprehension
    active_users = {row["user_id"] for row in response_data if row.get("is_active")}

    # Clean, transform, and map user payload states via a Dictionary Comprehension
    sanitized_directory = {
        user.lower(): {
            "role": row["role"].upper(),
            "email_domain": row["email"].split("@")[-1],
            "access_clearance": "High" if row["clearance_level"] > 3 else "Standard"
        }
        for row in response_data
        for user in [row.get("user_id", "")]  # Inline variable binding assignment
        if user in active_users
    }
    return sanitized_directory

# Execution Verification
raw_payload = [
    {"user_id": "Alice", "is_active": True, "role": "admin", "email": "alice@company.com", "clearance_level": 5},
    {"user_id": "Bob", "is_active": False, "role": "dev", "email": "bob@company.com", "clearance_level": 2},
    {"user_id": "Charlie", "is_active": True, "role": "analyst", "email": "charlie@partner.org", "clearance_level": 1}
]
print(sanitize_api_payload(raw_payload))

2. Iteration & Generators 🔄

The Iterable Protocol

An Iterable is any object that can return its elements one at a time (e.g., a list or string). Under the hood, the Iterable Protocol relies on two special methods:

__iter__(): Called automatically by Python loops to request an iterator object.
__next__(): Called on the iterator to fetch the next value. It raises a StopIteration exception when no elements are left.

Generators & `yield`

A Generator is a memory-efficient tool for handling massive datasets. Unlike standard functions that use return to pass back a finished list, a generator uses the yield keyword to output values one at a time. It pauses its state between calls, keeping only a single item in memory rather than storing the entire dataset.

Generator Functions: Defined using def but contain yield expressions.
Generator Expressions: High-performance, memory-saving alternatives to list comprehensions written inside parentheses (x for x in data).

🌱 Easy Starter Example

# Generator function yielding elements lazily on-demand
def countdown(start):
    while start > 0:
        yield start
        start -= 1

counter = countdown(3)
print(next(counter))  # Output: 3
print(next(counter))  # Output: 2

# Generator expression (stores zero array data in memory)
squared_gen = (x**2 for x in range(1000000))
print(next(squared_gen))  # Output: 0

🏛️ Real-World Example: Large Log Processing Pipeline

from pathlib import Path

def stream_huge_log_file(file_path: str):
    """Lazily reads a large file line-by-line to prevent high memory usage."""
    target = Path(file_path)
    if not target.exists():
        return

    with open(target, mode="r", encoding="utf-8") as file:
        for line in file:
            yield line.strip()

def filter_critical_events(log_stream):
    """Filters data streams item-by-item as elements pass through."""
    for log_line in log_stream:
        if "[CRITICAL]" in log_line:
            yield log_line.upper()

# Write fake log file for test execution context
Path("server.log").write_text("line 1\n[CRITICAL] DB Timeout\nline 3\n[CRITICAL] Out of Memory")

# Execution chain: Memory footprint stays tiny regardless of log size
raw_logs = stream_huge_log_file("server.log")
critical_alerts = filter_critical_events(raw_logs)

for alert in critical_alerts:
    print(f"Alert Triggered: {alert}")

3. Decorators 🎨

A Decorator is a structural design pattern that lets you modify or extend the behavior of a function or class without altering its original source code. Decorators wrap an outer closure layer around a target function.

Function Decorators: Standard layout syntax wrappers targeting single execution functions.
Decorators with Arguments: Advanced layout requiring a three-tier nested function configuration to accept configuration inputs.

🌱 Easy Starter Example

def simple_decorator(func):
    def wrapper(*args, **kwargs):
        print("Executing code before function call...")
        result = func(*args, **kwargs)
        print("Executing code after function call...")
        return result
    return wrapper

@simple_decorator
def greet(name):
    print(f"Hi {name}")

greet("Alex")

🏛️ Real-World Example: API Request Retry Wrapper with Custom Controls

import time
from functools import wraps

def retry(attempts: int, delay: float = 1.0):
    """A decorator that retries a function call if it encounters an exception."""
    def decorator(func):
        @wraps(func)  # Preserves target function metadata names and docstrings
        def wrapper(*args, **kwargs):
            last_error = None
            for current_attempt in range(1, attempts + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as error:
                    last_error = error
                    print(f"[Attempt {current_attempt}/{attempts}] Failure encountered: {error}. Retrying in {delay}s...")
                    time.sleep(delay)
            print("All retry threshold options exhausted.")
            raise last_error
        return wrapper
    return decorator

@retry(attempts=3, delay=0.5)
def unstable_network_fetch():
    raise ConnectionResetError("Remote server disconnected.")

try:
    unstable_network_fetch()
except ConnectionResetError:
    print("Caught final execution pipeline crash safely.")

4. Context Managers 🛠️

Context managers cleanly handle resource setup and teardown tasks using the with statement. This guarantees that files close, database locks release, and network connections drop properly, even if your application crashes mid-execution.

To create a custom context manager class, implement these two protocol methods:

__enter__(self): Allocates the target resource and returns it.
__exit__(self, exc_type, exc_val, exc_tb): Handles cleanup tasks automatically. If it returns True, it suppresses any runtime exceptions that occurred inside the with block.

🌱 Easy Starter Example

class CustomTimer:
    def __enter__(self):
        print("Resource reserved block.")
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Resource released block safely.")
        return False # Allow exceptions to bubble up normally

with CustomTimer():
    print("Running operations inside block.")

🏛️ Real-World Example: Production Mock Database Transaction Manager

class DBTransactionManager:
    def __init__(self, connection_uri: str):
        self.connection_uri = connection_uri
        self.transaction_active = False

    def __enter__(self):
        print(f"Connecting to: {self.connection_uri}")
        print("Starting SQL transaction block...")
        self.transaction_active = True
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is not None:
            # An error occurred inside the with block; trigger a rollback operation
            print(f"🚨 Exception caught: {exc_val}. Rolling back database modifications!")
            self.transaction_active = False
            # Return True to suppress the exception and prevent the app from crashing
            return True 

        # No errors occurred; commit the transaction changes safely
        print("✓ Transaction committed successfully. Closing database locks.")
        self.transaction_active = False
        return True

# Execution Trace A: Successful execution path
with DBTransactionManager("postgresql://localhost:5432/prod_db") as db:
    print("Writing user record info to database row indexes...")

print("---")

# Execution Trace B: Error handling path
with DBTransactionManager("postgresql://localhost:5432/prod_db") as db:
    print("Writing transaction lines...")
    raise IOError("Disk full! Cannot complete write operations.")
print("Application recovered successfully from exception state.")

5. Dataclasses 📊

Python's @dataclass decorator automatically writes standard boilerplate methods for your classes, such as __init__(), __repr__(), and comparison helper methods.

Default Values: Assign fields default parameters inline easily.
Frozen Dataclasses (frozen=True): Makes instances completely immutable (read-only) and hashable, allowing them to be safely used as dictionary keys or set elements.
Comparison Support (order=True): Auto-generates sorting evaluation triggers (<, >, <=, >=) based on the class fields in the order they are defined.

🌱 Easy Starter Example

from dataclasses import dataclass

@dataclass
class Coordinate:
    x: float
    y: float
    label: str = "Origin" # Default value allocation

pt1 = Coordinate(10.5, 20.0)
print(pt1) # Auto-generated __repr__ output: Coordinate(x=10.5, y=20.0, label='Origin')

🏛️ Real-World Example: High-Frequency Stock Trade Order Tracker

from dataclasses import dataclass, field
from datetime import datetime

@dataclass(frozen=True, order=True)
class StockTrade:
    # Fields are listed in order of sorting priority (timestamp evaluated first)
    execution_time: datetime = field(compare=True)
    ticker: str = field(compare=False)
    price: float = field(compare=True)
    shares: int = field(compare=False)
    order_type: str = field(default="BUY", compare=False)

# Instantiating read-only trading records
trade1 = StockTrade(datetime(2026, 7, 18, 10, 0), "AAPL", 185.50, 50)
trade2 = StockTrade(datetime(2026, 7, 18, 10, 5), "NVDA", 450.25, 20)
trade3 = StockTrade(datetime(2026, 7, 18, 9, 30), "AAPL", 184.00, 100)

# trade1.price = 190.00 # 🚨 Throws Dataclass AttributeError (Frozen Immutable Guard active)

# Sort collections seamlessly based on execution timelines and price points
trade_history = [trade1, trade2, trade3]
trade_history.sort()

for trade in trade_history:
    print(f"Time: {trade.execution_time} | Ticker: {trade.ticker} | Price: ${trade.price}")

6. Practice Challenge: Advanced Log Analytics Processing Engine 🏋️

Let's combine comprehensions, custom context managers, decorators, generators, and dataclasses into a functional log processing application.

Step 1: Bootstrap Project Infrastructure

Run the following initialization commands in your terminal workspace:

uv init advanced_challenge && cd advanced_challenge
touch log_engine.py

Step 2: Implement Code Base

Open log_engine.py and build out the data pipeline logic:

# log_engine.py
import time
from dataclasses import dataclass
from datetime import datetime
from functools import wraps
from pathlib import Path

# ==========================================
# 1. DATACLASS RESOURCE ARCHITECTURE
# ==========================================
@dataclass(frozen=True, order=True)
class LogMetric:
    severity: str
    timestamp: datetime
    message: str

# ==========================================
# 2. DECORATOR PERF TRACKER
# ==========================================
def monitor_runtime_performance(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        result = func(*args, **kwargs)
        duration = time.perf_counter() - start_time
        print(f"⚡ [Performance Metrics Summary]: Function '{func.__name__}' execution took {duration:.6f} seconds.")
        return result
    return wrapper

# ==========================================
# 3. CUSTOM CONTEXT FILE ENGINE MANAGER
# ==========================================
class ManagedLogSession:
    def __init__(self, filename: str):
        self.file_path = Path(filename)

    def __enter__(self):
        # Create a log file pre-populated with dummy data for this challenge run
        self.file_path.write_text(
            "INFO|2026-07-18 12:00:01|System initialization active.\n"
            "ERROR|2026-07-18 12:05:22|Database authentication failed timeout status.\n"
            "DEBUG|2026-07-18 12:06:00|Verbose memory collection dump completed.\n"
            "ERROR|2026-07-18 12:10:45|Network socket connection dropped abnormally.\n"
        )
        return self.file_path

    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file_path.exists():
            self.file_path.unlink() # Cleanup system footprint silently on completion
        return False

# ==========================================
# 4. STREAM GENERATOR LOGIC
# ==========================================
def generate_lazy_stream(file_path: Path):
    with open(file_path, mode="r", encoding="utf-8") as file:
        for line in file:
            if line.strip():
                yield line.strip()

# ==========================================
# 5. EXECUTION PIPELINE
# ==========================================
@monitor_runtime_performance
def process_log_pipeline(file_path: Path) -> list[LogMetric]:
    # Stream raw lines lazily
    raw_lines = generate_lazy_stream(file_path)

    # Parse items and construct LogMetric dataclass objects using list comprehensions
    parsed_metrics = [
        LogMetric(
            severity=parts[0],
            timestamp=datetime.strptime(parts[1], "%Y-%m-%d %H:%M:%S"),
            message=parts[2]
        )
        for line in raw_lines
        for parts in [line.split("|")]
        if parts[0] == "ERROR" # Comprehension filter conditional step
    ]

    return parsed_metrics

# ==========================================
# 6. RUNTIME ORCHESTRATION HARNESS
# ==========================================
if __name__ == "__main__":
    print("--- Starting Day 6 Orchestration Run ---")

    with ManagedLogSession("production_telemetry.log") as raw_log_file:
        # Process the log data through our performance-monitored generator pipeline
        error_metrics = process_log_pipeline(raw_log_file)

        print(f"\nFound {len(error_metrics)} critical system errors:")
        for metric in error_metrics:
            print(f"🚨 [{metric.severity}] - {metric.timestamp} -> {metric.message}")

    print("\n--- System cleanup completed successfully. Target log unlinked. ---")

Step 3: Run and Verify Your Project Pipeline

Execute your advanced processing engine via your terminal space:

uv run log_engine.py

#05 – Python File Handling & Exceptions

Thiruvengadam Sakthivel — Fri, 17 Jul 2026 18:36:35 +0000

Welcome to Day 5! Today we shift from volatile, temporary in-memory variables to persistent storage and application durability. You will learn how to interact safely with your operating system's file system, read/write structured industry data patterns, handle real-world operational crashes gracefully, and keep execution timelines documented using professional logging architectures. 💾

1. File Handling & `pathlib` 📄

Python's pathlib module treats file paths as smart object structures instead of plain text strings. This avoids bugs caused by differing slash directions across operating systems (Windows uses \, while Mac/Linux use /).

Reading ("r"): Loads file contents into memory.
Writing ("w"): Erases any existing file contents and writes a fresh payload from scratch.
Appending ("a"): Targets the end of a file, adding fresh text without overwriting existing contents.

🌱 Easy Starter Example

from pathlib import Path

# Create a path reference pointing to a file in the current workspace directory
file_path = Path("notes.txt")

# Write text cleanly to a file space
file_path.write_text("Hello from Day 5!")

# Read data straight back into a string variable
content = file_path.read_text()
print(content)  # Output: Hello from Day 5!

🏛️ Real-World Example: Multi-Platform System Telemetry Appender

from pathlib import Path
from datetime import datetime

def log_system_status(status_message: str) -> None:
    # Resolve home folder pathways seamlessly across Windows, Mac, or Linux systems
    target_dir = Path.home() / "app_workspace" / "telemetry"

    # Create the directory chain automatically if it doesn't exist yet
    target_dir.mkdir(parents=True, exist_ok=True)

    log_file = target_dir / "runtime_events.log"
    timestamp = datetime.now().isoformat()

    # Secure stream channel using Python's standard file-open context manager
    with open(log_file, mode="a", encoding="utf-8") as file:
        file.write(f"[{timestamp}] STATUS: {status_message}\n")

log_system_status("Core subsystem initialization sequence completed successfully.")

2. Structured Data Formats (JSON & CSV) 📊

A. JSON (JavaScript Object Notation)

JSON is a text format used for web data exchanges and configuration states. It mirrors Python dictionaries and lists.

🌱 Easy Starter Example

import json

user_profile = {"username": "alice", "active": True, "roles": ["admin", "dev"]}

# Convert a Python dictionary to a structured JSON data string
json_string = json.dumps(user_profile)
print(json_string)  # Output: {"username": "alice", "active": true, ...}

# Parse a JSON data string straight back into a standard Python dictionary
parsed_dict = json.loads(json_string)

🏛️ Real-World Example: Storing and Modifying Local Configuration Files

import json
from pathlib import Path

config_path = Path("settings.json")

# Write configuration updates safely into a localized file storage space
default_settings = {"theme": "dark", "port": 8080, "cache_enabled": True}
with open(config_path, mode="w", encoding="utf-8") as file:
    json.dump(default_settings, file, indent=4)

# Read, modify, and update configuration maps securely
if config_path.exists():
    with open(config_path, mode="r", encoding="utf-8") as file:
        current_config = json.load(file)

    # Modify parameter configurations
    current_config["theme"] = "dim-nordic-blue"

    with open(config_path, mode="w", encoding="utf-8") as file:
        json.dump(current_config, file, indent=4)

B. CSV (Comma-Separated Values)

CSV files store tabular spreadsheet data in plain text lines.

🌱 Easy Starter Example

import csv

# Writing records cleanly into rows
with open("basic.csv", mode="w", newline="", encoding="utf-8") as file:
    writer = csv.writer(file)
    writer.writerow(["Name", "Score"])
    writer.writerow(["Bob", "92"])

# Reading records straight back from rows
with open("basic.csv", mode="r", encoding="utf-8") as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)  # Output: ['Name', 'Score'], ['Bob', '92']

🏛️ Real-World Example: Product Inventory Report Processing Engine

import csv
from pathlib import Path

inventory_file = Path("warehouse_inventory.csv")

# Generate a cleanly tracked CSV document mapping item column cells out explicitly
products = [
    {"sku": "PROD-001", "name": "Mechanical Keyboard", "quantity": "45"},
    {"sku": "PROD-002", "name": "Ergonomic Mouse", "quantity": "120"}
]

with open(inventory_file, mode="w", newline="", encoding="utf-8") as file:
    # Use DictWriter to map dictionaries directly to structured CSV columns
    fieldnames = ["sku", "name", "quantity"]
    writer = csv.DictWriter(file, fieldnames=fieldnames)

    writer.writeheader()
    writer.writerows(products)

3. Exception Handling 🛠️

Exceptions are errors detected during application execution. Exception Handling keeps your program running smoothly when something goes wrong, instead of crashing unexpectedly.

try: Wraps code blocks that might trigger an unexpected error.
except: Code block that catches and handles specific runtime errors.
else: Runs only if the code inside the try block executes without any errors.
finally: Runs always, regardless of whether an error occurred or not. Ideal for cleanup tasks like closing database connections.
raise: Forces a specific error to occur intentionally.

🌱 Easy Starter Example

try:
    number = int(input("Enter a number to divide 10 by: "))
    result = 10 / number
except ZeroDivisionError:
    print("Error: You cannot divide numbers by zero.")
except ValueError:
    print("Error: Invalid character input. You must input digits.")
else:
    print(f"Calculation success! Answer is: {result}")
finally:
    print("Execution loop complete.")

🏛️ Real-World Example: Robust External API Data File Extraction Pipeline

from pathlib import Path

def fetch_transaction_payload(filename: str) -> str:
    target_file = Path(filename)

    try:
        # Code block might trigger a FileNotFoundError if missing
        with open(target_file, mode="r", encoding="utf-8") as file:
            data = file.read()
            if not data.strip():
                # Manually raise an explicit error flag if data payload is completely blank
                raise ValueError("Target file payload context space is completely empty.")

    except FileNotFoundError as error:
        return f"Operational Failure: Target file reference '{filename}' missing on disk. Details: {error}"
    except ValueError as validation_error:
        return f"Data Integrity Failure: {validation_error}"
    else:
        print("File parsed from local disks without encountering structural blocks.")
        return data
    finally:
        print("System resource locks released successfully.")

print(fetch_transaction_payload("missing_ledger.dat"))

4. Custom Exceptions 🚨

Standard exceptions (like ValueError) are often too broad. Creating Custom Exceptions lets you name specific errors after real-world issues in your business logic, making bugs much easier to trace.

🌱 Easy Starter Example

# Custom exception classes inherit directly from the base Exception class
class AgeRestrictionError(Exception):
    pass

def verify_voter_age(age: int):
    if age < 18:
        raise AgeRestrictionError("User is under the required voting age threshold.")
    print("Access granted.")

try:
    verify_voter_age(16)
except AgeRestrictionError as error:
    print(f"Registration Denied: {error}")

🏛️ Real-World Example: Digital Wallet Transaction Guardrail

class InsufficientFundsError(Exception):
    """Raised when an account attempts to withdraw more than their active balance."""
    def __init__(self, requested: float, available: float):
        super().__init__(f"Attempted to withdraw ${requested}, but only ${available} is available.")
        self.requested = requested
        self.available = available

class BankAccount:
    def __init__(self, owner: str, balance: float):
        self.owner = owner
        self.balance = balance

    def withdraw(self, amount: float) -> float:
        if amount > self.balance:
            # Trigger custom exception, passing runtime values into the error context
            raise InsufficientFundsError(amount, self.balance)
        self.balance -= amount
        return self.balance

# Execution verification handling loops
user_account = BankAccount("Sarah Jenkins", 250.00)
try:
    user_account.withdraw(400.00)
except InsufficientFundsError as error:
    print(f"[TRANSACTION BLOCKED] Overdraft prevention active: {error}")

5. Logging 🪵

Using print() to track errors is an anti-pattern; outputs disappear when the terminal closes. The logging module provides a permanent tracker that categorizes events by severity and writes them to disk.

Log Levels

Level	Severity Code Value	Core Functional Destination Purpose
`DEBUG`	10	Detailed diagnostic information for local debugging.
`INFO`	20	Confirms the application is working as expected.
`WARNING`	30	Indicates something unexpected happened, but the app can still run.
`ERROR`	40	A serious issue that caused a specific operation or function to fail.
`CRITICAL`	50	A fatal error that threatens to crash the entire application instantly.

🌱 Easy Starter Example

import logging

# Simple logger configuration setup out of the box
logging.basicConfig(level=logging.INFO)

logging.info("System process successfully started.")
logging.warning("Disk space approaching filled capacity limits.")
logging.error("Database connection dropped.")

🏛️ Real-World Example: Enterprise Application Logging Architecture

import logging
from pathlib import Path

def initialize_production_logger():
    log_dir = Path("logs")
    log_dir.mkdir(exist_ok=True)

    # Configure production logger to write messages to a file with timestamps
    logging.basicConfig(
        filename=log_dir / "production_runtime.log",
        filemode="a",
        format="%(asctime)s - [%(levelname)s] - %(name)s - %(message)s",
        level=logging.WARNING # Directs the application to log only WARNING level issues or worse
    )

initialize_production_logger()
logger = logging.getLogger("PaymentGateway")

def process_credit_card():
    try:
        # Simulating external microservice outage breakdown error states
        raise ConnectionRefusedError("Payment processor API endpoint timeout.")
    except ConnectionRefusedError as error:
        # Logs the detailed stack trace to your file automatically
        logger.error("Failed to process transaction securely.", exc_info=True)

process_credit_card()

6. Practice Challenge: Data Processing Engine 🏋️

Let’s combine everything from today into a single, comprehensive exercise. We will write a data ingestion script that reads a user dataset from a file, validates the information using custom exceptions, and logs everything to a localized metrics file.

Step 1: Set Up Your Project Files

Using your terminal skills from Day 4, create a workspace with a fresh script file:

uv init day_5_challenge && cd day_5_challenge
touch data_processor.py

Step 2: Implement the Code Base

Open data_processor.py and implement the production data parsing pipeline:

# data_processor.py
import json
import csv
import logging
from pathlib import Path

# 1. Configure the system logging tracking layout
logging.basicConfig(
    filename=Path("system_execution.log"),
    filemode="w",
    format="%(asctime)s - [%(levelname)s] - %(message)s",
    level=logging.INFO
)
logger = logging.getLogger("DataProcessor")

# 2. Define custom domain error exception patterns
class InvalidUserDataError(Exception):
    """Raised when user data records fail business rule validation criteria."""
    pass

# 3. Implement parsing pipeline logic
def validate_and_transform_records(raw_csv_path: str, output_json_path: str) -> None:
    source_file = Path(raw_csv_path)
    destination_file = Path(output_json_path)
    processed_records = []

    logger.info("Initializing raw transaction CSV import pipeline.")

    try:
        with open(source_file, mode="r", encoding="utf-8") as file:
            reader = csv.DictReader(file)

            for row_index, row in enumerate(reader, start=1):
                try:
                    username = row.get("username", "").strip()
                    email = row.get("email", "").strip()
                    age_str = row.get("age", "").strip()

                    # Core Validation Rules: Check for missing data fields
                    if not username or not email or not age_str:
                        raise InvalidUserDataError(f"Row {row_index}: Missing critical data fields.")

                    age = int(age_str)
                    if age <= 0 or age > 120:
                        raise InvalidUserDataError(f"Row {row_index}: Age context constraint anomaly ({age}).")

                    # Data Transformation step
                    processed_records.append({
                        "user_id": username.lower(),
                        "contact": email,
                        "years_active": age,
                        "verified_status": True if age >= 18 else False
                    })
                    logger.info(f"Successfully processed user record: '{username}'.")

                except InvalidUserDataError as data_error:
                    logger.warning(f"Skipping row registry error: {data_error}")
                except ValueError:
                    logger.warning(f"Skipping row {row_index}: Failed parsing age string component to numerical digit.")

    except FileNotFoundError:
        logger.critical(f"Pipeline processing halted. Source input file missing: '{raw_csv_path}'")
        print("Fatal Error: Source database file not found. Check system execution logs.")
        return

    # Write successfully processed data records out to JSON format storage
    try:
        with open(destination_file, mode="w", encoding="utf-8") as out_file:
            json.dump(processed_records, out_file, indent=4)
        logger.info(f"Ingestion successful! Saved {len(processed_records)} records to '{output_json_path}'.")
        print(f"Success! Processed data exported cleanly to {output_json_path}")
    except Exception as general_error:
        logger.error(f"Failed exporting JSON package data: {general_error}")

# 4. Local Execution Test Suite Harness Setup
if __name__ == "__main__":
    # Generate dummy source data for testing the validation loops
    raw_data_path = "source_users.csv"
    with open(raw_data_path, mode="w", newline="", encoding="utf-8") as test_csv:
        writer = csv.writer(test_csv)
        writer.writerow(["username", "email", "age"])
        writer.writerow(["s_rogers", "cap@avengers.org", "102"])  # Valid Row
        writer.writerow(["t_stark", "", "48"])                  # Invalid Row: Missing Email
        writer.writerow(["p_parker", "spidey@dailybugle.com", "-5"]) # Invalid Row: Bad Age
        writer.writerow(["b_banner", "hulk@smash.com", "51"])    # Valid Row

    # Run the data pipeline processing execution
    validate_and_transform_records(raw_data_path, "cleansed_output.json")

Step 3: Run and Verify Your Outputs

Execute your processing engine script inside your terminal space:

uv run data_processor.py

Now, check the generated outputs. Your cleansed_output.json file will contain only the verified rows:

[
    {
        "user_id": "s_rogers",
        "contact": "cap@avengers.org",
        "years_active": 102,
        "verified_status": true
    },
    {
        "user_id": "b_banner",
        "contact": "hulk@smash.com",
        "years_active": 51,
        "verified_status": true
    }
]

Open system_execution.log to review how the engine tracked errors behind the scenes without crashing:

2026-07-17 23:59:00,124 - [INFO] - Initializing raw transaction CSV import pipeline.
2026-07-17 23:59:00,125 - [INFO] - Successfully processed user record: 's_rogers'.
2026-07-17 23:59:00,125 - [WARNING] - Skipping row registry error: Row 3: Missing critical data fields.
2026-07-17 23:59:00,126 - [WARNING] - Skipping row registry error: Row 4: Age context constraint anomaly (-5).
2026-07-17 23:59:00,126 - [INFO] - Successfully processed user record: 'b_banner'.
2026-07-17 23:59:00,127 - [INFO] - Ingestion successful! Saved 2 records to 'cleansed_output.json'.

#04 – Modules & Modern Python Project Structure

Thiruvengadam Sakthivel — Thu, 16 Jul 2026 15:34:43 +0000

Welcome to Day 4! Today is all about clean architecture, dependency isolation, and modern Python tooling. You will learn how to structure your files, control execution flows, use modern tools like uv to manage virtual environments at lightning speed, and organize a codebase like a professional software engineer. 🚀

1. Modules & Packages 📦

Module: A single .py file containing variables, functions, or classes you want to reuse.
Package: A directory of modules.
__init__.py: Runs automatically when a package is imported, allowing you to expose a clean top-level API and hide internal folder nesting.
Absolute Import: Imports specifying the full path from the project root (from app.core import analyze). Preferred by PEP 8.
Relative Import: Imports relative to the current file using dots (from .utils import clean). Single dot . is current folder; double dot .. is parent folder.

A. Core Modules & Packages

🌱 Easy Starter Example

Creating a basic module and importing it:

# file: calculator.py (Our module)
def add(a, b):
    return a + b

# file: main.py (Importing our module)
import calculator
print(calculator.add(5, 3))  # Output: 8

🏛️ Real-World Example: Database Package API

Exposing internal package functions cleanly using __init__.py:

# Project Layout:
database/
   ├── __init__.py
   ├── auth.py       (defines login_user())
   └── query.py      (defines fetch_data())

# database/__init__.py
# Expose functions relative to this folder so users don't need deep imports
from .auth import login_user
from .query import fetch_data

# main.py
# Clean absolute package import for the end-user
from database import login_user, fetch_data  

login_user("admin", "password123")

B. Built-In vs. Third-Party Modules

Built-In: Included with Python out-of-the-box (e.g., os, sys, json).
Third-Party: Built by the community and installed from PyPI (e.g., requests, rich).

🌱 Easy Starter Example

import math              # Built-in math operations
print(math.sqrt(25))     # Output: 5.0

# import requests        # Third-party (Will fail until installed!)

🏛️ Real-World Example: System Health Report

Combining built-ins with third-party styling packages to log environmental diagnostics:

import os
import sys
import json
# from rich import print  # Third-party library for colorized terminal output

def generate_report():
    sys_info = {
        "os_name": os.name,
        "python_ver": sys.version.split()[0],
        "current_directory": os.getcwd()
    }
    # Convert Python dictionary to formatted JSON string using built-in library
    json_report = json.dumps(sys_info, indent=2)
    print(json_report)

generate_report()

2. Special Variables & Entry Points 🪄

Python tracks a hidden string variable named __name__ for every file.

If you run a file directly, __name__ evaluates to "__main__".
If a file is imported, __name__ evaluates to its actual filename.

The Entry Point Pattern (if __name__ == "__main__":) acts as a safety guardrail. It prevents script logic from running automatically when a module is imported.

🌱 Easy Starter Example

# file: greeter.py
def hello():
    print("Hello from greeter!")

# Direct run safety guard
if __name__ == "__main__":
    print("This runs ONLY when executing greeter.py directly.")
    hello()

🏛️ Real-World Example: Database Seeder Script

A script that imports utility functions, but includes local testing/seeding operations that should never run during production imports.

# file: db_migrator.py
def run_migrations():
    print("Applying schema updates to database...")

if __name__ == "__main__":
    # Local CLI testing execution block. Safe from running on production imports!
    print("--- Local Debug Mode: Initializing Test Seeder ---")
    run_migrations()
    print("Test migrations complete.")

3. Modern Project Structure 🏛️

For professional applications, organizing your project elements systematically keeps your codebase scalable, deployable, and testable.

🌱 Easy Starter Example

A basic folder layout for a small personal script:

my_script_project/
├── .gitignore
├── README.md
├── main.py
└── utils.py

🏛️ Real-World Example: Enterprise Layout

A highly structured layout for a production microservice:

my_project/
├── .git/                 # Git Version Control
├── .gitignore            # Excludes build caches and virtual environments
├── README.md             # Setup guide and API documentation
├── pyproject.toml        # Unified project metadata and dependencies (PEP 621)
├── uv.lock               # Pinned reproducible environment version lockfile
├── main.py               # Main application entry point
├── app/                  # Core application package folder
│   ├── __init__.py
│   ├── core.py
│   └── utils.py
└── tests/                # Automated test suite
    └── test_core.py

4. Virtual Environments & Package Management 🌐

Virtual Environments (.venv) act as isolated sandboxes. If Project A needs Django v4.0 and Project B needs Django v5.0, global installations will break one of them. Environments keep their setups completely separate.

While classic Python uses pip, uv (written in Rust) acts as the modern industry gold standard—performing setup, installation, and compilation tasks 10–100x faster.

Pip vs. UV Commands Reference

Action	Classic `pip` + `venv` Way	Modern `uv` Way
Initialize Workspace	(Manual directory config)	`uv init my_project`
Create `.venv` Room	`python -m venv .venv`	`uv venv`
Activate Env (Mac/Linux)	`source .venv/bin/activate`	`source .venv/bin/activate`
Activate Env (Windows)	`.venv\Scripts\activate`	`.venv\Scripts\activate`
Install Package	`pip install requests`	`uv add requests`
Upgrade Package	`pip install --upgrade requests`	`uv add requests --upgrade`
Uninstall Package	`pip uninstall requests`	`uv remove requests`
Lock Environment	`pip freeze > requirements.txt`	(Auto-tracked in `pyproject.toml` / `uv.lock`)
Sync Environment	`pip install -r requirements.txt`	`uv sync`
Run Script	`python main.py` (Requires activation)	`uv run main.py` (Auto-manages active env)

🌱 Easy Starter Example: Isolate a package with `pip`

# Classic manual setup
python -m venv .venv
source .venv/bin/activate
pip install requests
python -c "import requests; print(requests.__version__)"

🏛️ Real-World Example: Modernized `uv` workflow

# Initialize a modern template in one command
uv init my_app && cd my_app

# Add dependencies instantly to local metadata & venv
uv add requests

# Run your application immediately (uv auto-manages the environment)
uv run hello.py

5. Practice Challenge: Create a Modern Modular Project 🏋️

Let's build a structured, modular Text Processor App under Git version control using uv.

Step 1: Initialize Workspace Layout

Open your terminal and build your project architecture:

uv init text_utility_app && cd text_utility_app
git init
mkdir app tests
touch app/__init__.py app/core.py app/utils.py tests/test_core.py

Step 2: Establish the Project Ignore Bounds

Prevent tracking compiled cache databases or workspace binaries in Git:

# Create a .gitignore file in the root directory
# .gitignore
.venv/
__pycache__/
*.pyc
.uv/

Step 3: Implement Code Base

Create your utility parsing module:

# app/utils.py
def clean_whitespace(text: str) -> str:
    """Strips extra outer spaces and condenses internal gaps."""
    return " ".join(text.split())

Create your analysis core, calling your sibling utility relative to its position:

# app/core.py
import json # Built-in module dependency
from .utils import clean_whitespace # Relative package import

def analyze_to_json(text: str) -> str:
    """Cleans text and packs word counts into a JSON string."""
    cleaned = clean_whitespace(text)
    metrics = {
        "original_text": text,
        "cleaned_text": cleaned,
        "word_count": len(cleaned.split()) if text.strip() else 0
    }
    return json.dumps(metrics)

Map imports inside your package initialization gateway:

# app/__init__.py
# Expose functions directly to package consumers
from .core import analyze_to_json

Create the application entry point using a third-party styling package:

# main.py
from app import analyze_to_json # Custom package import
from rich import print # Third-party style library

if __name__ == "__main__":
    raw_payload = "   Day  4   Modules   System  Activated   "
    json_result = analyze_to_json(raw_payload)

    print("[bold cyan]=== Processing Dashboard ===[/bold cyan]")
    print(json_result)

Create local verification assertions:

# tests/test_core.py
from app.utils import clean_whitespace # Absolute project import

def test_string_cleaner():
    assert clean_whitespace("   too    many   spaces   ") == "too many spaces"
    print("✓ Unit test diagnostics passed.")

if __name__ == "__main__":
    test_string_cleaner()

Step 4: Resolve, Execute, and Save

Let uv handle installation, compile configurations, and build synchronization.

# Add third-party styling to pyproject.toml and env automatically
uv add rich

# Run the execution pipeline instantly
uv run main.py

# Run unit verification tests
uv run python tests/test_core.py

# Commit progress to Git
git add .
git commit -m "Feat: Complete modular project using uv and app package"

#03: Python Functions & Functional Power

Thiruvengadam Sakthivel — Wed, 15 Jul 2026 18:01:20 +0000

Welcome to Day 3! Today, we transition from writing basic scripts to building reusable, modular, and highly flexible building blocks. We will look at how Python handles arguments, the strict rules of variable scope, and how functions can be treated as first-class citizens to create highly dynamic utilities. 🚀

1. Parameters & Arguments (Default & Keyword-Only) ⚙️

In Python, you can define parameters that make your functions incredibly flexible.

Default Arguments: Allow you to set fallback values for parameters if the caller doesn't provide them.
Keyword-Only Arguments: Enforce that certain arguments must be passed by name rather than position. You declare these by placing an asterisk * in your parameter list; everything after the * must be named.

🌱 Easy Starter Example

# 'msg' has a default value. 'shout' is a keyword-only argument.
def greet(name, msg="Hello", *, shout=False):
    greeting = f"{msg}, {name}!"
    return greeting.upper() if shout else greeting

# Usage
print(greet("Alice"))                 # Output: Hello, Alice!
print(greet("Bob", "Welcome"))        # Output: Welcome, Bob!
# print(greet("Charlie", shout=True)) # Output: HELLO, CHARLIE!
# greet("Dave", "Hi", True)           # ❌ TypeError: keyword-only argument required

Real-World Application Example: API Request Configurer 🔌

# Enforcing safety defaults for API timeouts and token visibility
def send_request(url, payload, *, timeout=10, retries=3):
    print(f"Sending data to {url} (Timeout: {timeout}s, Retries: {retries})")
    # Request logic would go here...

# Caller must explicitly state overrides, preventing accidental index errors
send_request("https://api.example.com", {"data": 1}, timeout=5, retries=1)

2. `*args` and `kwargs` (Dynamic Arity) 📦

Sometimes you don't know exactly how many arguments a user will pass to your function.

*args collects extra positional arguments into a Tuple.
kwargs collects extra keyword arguments into a Dictionary.

🌱 Easy Starter Example

def dynamic_demo(*args, **kwargs):
    print("args:", args)      # Tuple of positional args
    print("kwargs:", kwargs)  # Dict of keyword args

dynamic_demo(1, 2, 3, user="Dev", role="Admin")
# Output:
# args: (1, 2, 3)
# kwargs: {'user': 'Dev', 'role': 'Admin'}

Real-World Application Example: HTML Element Generator 🎨

def build_html_tag(tag_name, *content, **attributes):
    # Format the attributes dict into a string of key="value"
    attr_str = "".join([f' {key}="{val}"' for key, val in attributes.items()])
    # Join all separate content items together
    inner_text = " ".join(content)

    return f"<{tag_name}{attr_str}>{inner_text}</{tag_name}>"

# Create a customized HTML link
link = build_html_tag("a", "Click", "Here", "To", "Learn", href="https://python.org", target="_blank")
print(link)
# Output: <a href="https://python.org" target="_blank">Click Here To Learn</a>

3. Scope & The LEGB Rule 🌐

Variable visibility in Python is governed by the LEGB Rule. When you look up a variable name, Python checks four scopes in a strict order:

Local: Inside the current function.
Enclosing: Inside any enclosing (outer) functions (relevant to nested functions/closures).
Global: At the top level of the module/file.
Built-in: Python's pre-loaded keywords (like len, sum, print).

🌱 Easy Starter Example

x = "Global"

def outer_function():
    x = "Enclosing"

    def inner_function():
        x = "Local"
        print(f"Inside inner: {x}") # Finds Local first

    inner_function()
    print(f"Inside outer: {x}")     # Finds Enclosing first

outer_function()
print(f"Global scope: {x}")         # Finds Global first

Real-World Application Example: Modifying Enclosing Scope 🔧

# To modify variables in Global or Enclosing scopes, use 'global' or 'nonlocal'
def create_click_counter():
    count = 0  # Enclosing scope variable

    def click():
        nonlocal count  # Declares we want to edit 'count' from the outer function
        count += 1
        return count

    return click

counter = create_click_counter()
print(counter())  # Output: 1
print(counter())  # Output: 2

4. First-Class Functions & Closures 🤝

In Python, functions are First-Class Citizens. This means you can assign them to variables, pass them as arguments to other functions, and even return them from other functions.

A Closure is an inner function that "remembers" and has access to variables from its enclosing outer scope, even after the outer function has finished executing.

🌱 Easy Starter Example

def make_multiplier(factor):
    # This is a closure! It remembers 'factor'
    def multiply(number):
        return number * factor
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)

print(double(10)) # Output: 20
print(triple(10)) # Output: 30

Real-World Application Example: Custom Logger Creator 📝

import datetime

# Create customized loggers with specific prefix headers
def make_logger(prefix: str):
    def log(message: str) -> None:
        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{timestamp}] [{prefix.upper()}]: {message}")
    return log

# Instantiate tailored logging functions
info_log = make_logger("info")
error_log = make_logger("error")

# Usage
info_log("Server started successfully.")
error_log("Database connection timeout.")

5. Practice Challenge: Building Reusable Utility Functions 🏋️

Let's tie all these rules together to build a robust Data Processing Utility Engine.

We want to build a reusable utility function that processes data tables (lists of dictionaries) by applying custom transformations, filtering rules, and applying fallback configuration defaults.

# 1. Custom transformation functions (First-Class Functions)
def tax_calculator(amount):
    return amount * 1.15

def uppercase_formatter(text):
    return str(text).upper()


# 2. Main data processor utility utilizing *args, **kwargs, and keyword defaults
def process_transactions(transactions: list[dict], *fields_to_transform, transformer_func, **default_fallbacks) -> list[dict]:
    """
    Processes transaction logs by applying a 'transformer_func' to specified fields.
    Fills in any missing fields using key-value 'default_fallbacks'.
    """
    processed_data = []

    for item in transactions:
        # Create a shallow copy to keep the original list pure
        temp_item = item.copy()

        # Apply fallbacks for missing data
        for key, val in default_fallbacks.items():
            if key not in temp_item:
                temp_item[key] = val

        # Apply transformation to specified fields (passed via *args)
        for field in fields_to_transform:
            if field in temp_item:
                temp_item[field] = transformer_func(temp_item[field])

        processed_data.append(temp_item)

    return processed_data


# --- RUNNING THE UTILITY ---

raw_invoices = [
    {"invoice_id": "inv_001", "subtotal": 100},
    {"invoice_id": "inv_002", "subtotal": 250, "currency": "USD"},
    {"invoice_id": "inv_003"}, # Missing invoice_id and subtotal fields
]

# Run processor to apply tax calculation on subtotal and default missing currency to 'EUR'
completed_invoices = process_transactions(
    raw_invoices, 
    "subtotal",                 # *args: Fields to modify
    transformer_func=tax_calculator,  # Keyword-only transformer
    currency="EUR",             # **kwargs: Fallbacks
    subtotal=0.0                # **kwargs: Fallbacks
)

for invoice in completed_invoices:
    print(invoice)

# Output:
# {'invoice_id': 'inv_001', 'subtotal': 114.99999999999999, 'currency': 'EUR'}
# {'invoice_id': 'inv_002', 'subtotal': 287.5, 'currency': 'USD'}
# {'invoice_id': 'inv_003', 'currency': 'EUR', 'subtotal': 0.0}

#02: Collections & Data Transformation in Python

Thiruvengadam Sakthivel — Tue, 14 Jul 2026 15:51:08 +0000

1. The Big Four Collections 📚

Python has four primary built-in data collections. Choosing the right one depends entirely on your data structure requirements (e.g., whether order matters or if duplicates are allowed).

Collection	Ordered?	Mutable (Editable)?	Duplicates Allowed?	Syntax	Best Used For...
List	✅ Yes	✅ Yes	✅ Yes	`[]`	Sequential data, logs, stacks of items.
Tuple	✅ Yes	❌ No	✅ Yes	`()`	Fixed structures, coordinate pairs, database rows.
Set	❌ No	✅ Yes	❌ No	`{}`	Eliminating duplicates, mathematical operations.
Dictionary	✅ Yes (3.7+)	✅ Yes	❌ No (Keys must be unique)	`{"k": "v"}`	Fast lookups, JSON data, structured records.

🌱 Easy Starter Example

my_list = [1, 2, 2, 3]       # Allows duplicates: [1, 2, 2, 3]
my_tuple = (1, 2, 3)         # Can't change it later!
my_set = {1, 2, 2, 3}         # Drops duplicates automatically: {1, 2, 3}
my_dict = {"apple": 5}       # Key-value lookup map

Real-World Application Example 🛠️

# List: Maintaining a sequence of logs
error_logs = ["404 Not Found", "500 Internal Error", "404 Not Found"]
error_logs.append("403 Forbidden")  

# Tuple: A strict 3D coordinate point 
point_3d = (12.5, 45.0, -3.1)

# Set: Stripping out duplicates instantly
unique_errors = set(error_logs)
print(unique_errors)  # Output: {'500 Internal Error', '403 Forbidden', '404 Not Found'}

# Dictionary: Mapping a user record
user_profile = {"username": "coder_99", "role": "Admin", "verified": True}

2. Powerful Iteration Helpers ⚙️

When transforming data, looping with a basic index counter is an anti-pattern. Instead, Python offers three foundational functions to loop like a pro.

🔢 `enumerate()`

Tracks both the index and the item value simultaneously while looping through a sequence.

🌱 Easy Starter Example:

for index, letter in enumerate(["a", "b", "c"]):
    print(index, letter)  # Output: 0 a, 1 b, 2 c

Real-World Application:

tasks = ["Download data", "Clean missing values", "Train model"]
for index, task in enumerate(tasks, start=1):
    print(f"Step {index}: {task}")

🤐 `zip()`

Pairs up elements from multiple lists or tuples into matched pairs. It stops as soon as the shortest list runs out.

🌱 Easy Starter Example:

print(list(zip([1, 2], ["apple", "banana"]))) 
# Output: [(1, 'apple'), (2, 'banana')]

Real-World Application:

names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(f"{name} scored {score}%")

📐 `sorted()`

Returns a new sorted list from any iterable without modifying the original data structure.

🌱 Easy Starter Example:

print(sorted([3, 1, 2]))  # Output: [1, 2, 3]

Real-World Application:

temperatures = [32, 12, 45, 22]
descending_temps = sorted(temperatures, reverse=True)  # [45, 32, 22, 12]

3. Lambda Functions (Anonymous Functions) ⚡

A lambda function is a small, one-line anonymous function defined without the standard def keyword. They are ideal for quick, throwaway sorting or mapping operations.

Syntax: lambda arguments: expression

🌱 Easy Starter Example

# A simple function that doubles a number
double = lambda x: x * 2
print(double(5))  # Output: 10

Real-World Application Example: Sorting Complex Structures 🔍

products = [
    {"name": "Laptop", "price": 1200},
    {"name": "Mouse", "price": 25},
    {"name": "Monitor", "price": 300}
]

# Sort the products list by price using a lambda function as the sorting key
sorted_by_price = sorted(products, key=lambda item: item["price"])
print(sorted_by_price)
# Output: [{'name': 'Mouse', 'price': 25}, {'name': 'Monitor', 'price': 300}, ...]

4. Comprehensions (Data Transformation Engines) 🏎️

Comprehensions provide a concise, readable syntax to create a new collection based on an existing collection, effectively replacing bulky for loops.

🧺 List Comprehension

🌱 Easy Starter Example:

# Double every number in a list
doubled = [x * 2 for x in [1, 2, 3]]  # Output: [2, 4, 6]

Real-World Application:

prices_usd = [10, 25, 50]
prices_eur = [price * 0.92 for price in prices_usd] # [9.2, 23.0, 46.0]

# With a condition filter (Only keep items over $20)
expensive_items = [price for price in prices_usd if price >= 25] # [25, 50]

🗺️ Dictionary & Set Comprehensions

🌱 Easy Starter Example:

# Create a quick number-to-square map
squares = {x: x*x for x in [1, 2, 3]}  # Output: {1: 1, 2: 4, 3: 9}

Real-World Application:

# Set Comprehension: Extract unique file extensions, converted to lowercase
raw_files = ["Data.CSV", "script.py", "readme.md", "Archive.csv"]
unique_extensions = {file.split(".")[-1].lower() for file in raw_files}
print(unique_extensions) # Output: {'csv', 'py', 'md'}

5. Practice Challenge: Processing & Transforming Structured Data 🏋️

Let's tie Day 2 together! Imagine you receive a messy API payload of users. Your task is to filter out inactive users, format their names, and map their IDs to their profile details.

# Raw structured input data
raw_users = [
    {"id": 101, "name": "alice smith", "is_active": True},
    {"id": 102, "name": "BOB JOHNSON", "is_active": False},
    {"id": 103, "name": "charlie brown", "is_active": True},
]

# 1. Use list comprehension to filter out inactive users and format names cleanly
active_users = [
    {"id": user["id"], "name": user["name"].title()} 
    for user in raw_users if user["is_active"]
]
print("Active Users:", active_users)
# Output: [{'id': 101, 'name': 'Alice Smith'}, {'id': 103, 'name': 'Charlie Brown'}]

# 2. Use dictionary comprehension to build a fast ID lookup database
user_database = {user["id"]: user["name"] for user in active_users}
print("User Database Map:", user_database)
# Output: {101: 'Alice Smith', 103: 'Charlie Brown'}

#01: Python Syntax & Idioms

Thiruvengadam Sakthivel — Mon, 13 Jul 2026 15:59:45 +0000

Welcome to Day 1! Python is famous for its clean, readable syntax—often described as "executable pseudocode." This guide covers the foundational idioms you need to write clean, Pythonic code from the start.

1. What is Python?

Python is a high-level, interpreted, dynamically typed programming language.

High-level: You don't have to manage memory or worry about hardware details. 🧠
Interpreted: Code is executed line-by-line by the Python interpreter at runtime, meaning there is no separate compilation step. ⚡
Dynamically typed: You don’t need to state whether a variable is a number, text, or a list when you create it. Python figures it out automatically. ⚙️

Code Example: Dynamic Typing

Because Python is dynamically typed, the same variable name can point to entirely different types of data over time.

Python

current_status = "Learning"  # Starts as a string (str)
print(type(current_status))  # Output: <class 'str'>

current_status = 100         # Changes to an integer (int)
print(type(current_status))  # Output: <class 'int'>

2. Variables & Naming Conventions 🏷️

In Python, a variable is not a physical "box" that holds data; it is a label or pointer attached to an object in memory. Following the standard Python style guide (PEP 8) keeps your code clean and readable for other developers. 🤝

Naming Rules (PEP 8):

snake_case: Lowercase letters with underscores for variables and functions.
PascalCase: Capitalize the first letter of each word for class names.
UPPERCASE: All caps for constants (variables meant to remain unchanged).
Variables cannot start with a number and are strictly case-sensitive (age and Age are distinct).

Code Example: Pythonic Naming

Python

# 👍 GOOD (Pythonic style)
user_growth_rate = 12.5      # snake_case for variables
def calculate_roi(): pass    # snake_case for functions
MAX_TIMEOUT_SECONDS = 30     # UPPERCASE for constants

# 👎 BAD (Unpythonic syntax or errors)
userGrowthRate = 12.5        # Avoid camelCase in standard Python
UserGrowthRate = 12.5        # Avoid PascalCase for normal variables (save for Classes)
3_strikes_rule = "Out"       # SyntaxError: Cannot start with a number

3. Data Types 📊

Python handles several built-in data types out of the box. They are broadly split into single scalar values and multi-item collections. 🗂️

Category	Type	Description	Example
Numeric	`int`, `float`	Integers and decimal numbers	`42`, `3.14`
Text	`str`	Text string literals	`"Hello, Python!"`
Boolean	`bool`	True or False states	`True`, `False`
Sequence	`list`	Ordered, editable (mutable) collection	`["python", "coding"]`
Sequence	`tuple`	Ordered, unchangeable (immutable) array	`(1920, 1080)`
Mapping	`dict`	Key-value pairs (dictionaries)	`{"id": 101, "name": "Alice"}`
Set	`set`	Unordered collection of unique items	`{1, 2, 3}`

Code Example: Declaring Types

Python

# Scalar Types
age = 28                         
price = 49.99                    
is_active = True                 

# Collection Types
tags = ["python", "coding"]      # list
dimensions = (1920, 1080)        # tuple (great for structural data like coordinates)
user_profile = {"id": 101}       # dict
unique_ids = {101, 102, 101}     # set (automatically drops duplicates, leaving {101, 102})

4. Truthy & Falsy Values 🤔

In Python, every single value evaluates to a boolean context when used inside a conditional statement (like an if block). A value is either Truthy (behaves like True) or Falsy (behaves like False).

Instead of writing clunky checks like if len(my_list) == 0:, the idiomatic Python approach is simply if not my_list:. 🎯

The Falsy Hall of Fame:

None
False
Zero of any numeric type: 0, 0.0
Empty sequences and collections: "", [], (), {}, set()
Everything else is considered Truthy. ✨

Code Example: Clean Boolean Checks

Python

# Checking for an empty string input
submitted_username = "" # Empty string is Falsy

if not submitted_username:
    print("Error: Username cannot be blank.")

# Checking a populated list
active_notifications = ["Alert: Low Battery", "Update Available"] # Populated list is Truthy

if active_notifications:
    print(f"You have {len(active_notifications)} unread notifications.")

5. f-Strings (Formatted String Literals) ⚡

f-strings are the gold standard for embedding variables or running expressions directly inside strings. Just prefix your string with an f or F and use curly braces {}. 🛠️

Code Example: Evaluation and Formatting

Python

# Math expressions and variables inside a string
item = "Coffee"
price = 4.50
quantity = 3
print(f"Total for {quantity} {item}s: ${price * quantity}") 
# Output: Total for 3 Coffees: $13.5

# Formatting floats (limiting decimal places)
pi_value = 3.14159265
print(f"Pi to two decimal places: {pi_value:.2f}") 
# Output: Pi to two decimal places: 3.14

6. Multiple Assignment & Unpacking 🎁

Python allows you to assign values to multiple variables simultaneously or pull elements out of sequences cleanly in a single line. This lets you write incredibly elegant, line-saving code. 🪄

Code Example: The Variable Swap & Target Unpacking

Python

# The classic variable swap (No temporary third variable required!)
a = "Water"
b = "Wine"

a, b = b, a 
print(f"a: {a}, b: {b}") # Output: a: Wine, b: Water

# Unpacking elements from structural tuples
coordinates = (40.7128, -74.0060)
lat, lon = coordinates  # lat = 40.7128, lon = -74.0060

# Ignoring specific values during unpacking using an underscore (_)
api_response = (200, "Success", {"user_id": 42})
status_code, _, data = api_response # We choose to ignore the middle message string

# Advanced unpacking using the * (star) operator
numbers = [1, 2, 3, 4, 5]
first, second, *rest = numbers
print(rest)   # Output: [3, 4, 5]

7. Type Hints 💡

Because Python is dynamically typed, scripts can become confusing as they scale. Type hints allow you to explicitly document what kind of data variables and functions expect. 📝

Note: Python does not enforce these types at runtime. They exist for readability, auto-complete help in your IDE, and static analysis checkers like mypy. 🔍

Code Example: Hinting Functions and Collections

Python

# Hinting function inputs and return outputs
def calculate_tax(amount: float, tax_rate: float) -> float:
    return amount * tax_rate

# Hinting standalone variables and built-in collections
score: int = 100
is_game_over: bool = False

# Native collection hinting (Python 3.9+)
guest_list: list[str] = ["Alice", "Bob", "Charlie"]
inventory_count: dict[str, int] = {"Apples": 50, "Oranges": 20}

DEV Community: Thiruvengadam Sakthivel

#05 -Python's Hidden Superpowers: Special (Magic) Methods Explained

1. Categorizing Core Dunder Methods 🗂️

2. Topic Breakdown 💡

1. Object Representation: __str__ vs __repr__

2. Sizing & Comparisons: __len__, __eq__, __lt__

3. Iteration & Callables: __iter__, __call__

4. Context Management: __enter__, __exit__

3. Practice Challenge: Custom SmartBatch Pipeline 🚀

Step 1: Initialize Your Workspace

Step 2: Implement smart_batch.py

Step 3: Run & Verify Execution

Output Summary

#04 - Connecting Objects: Understanding Object Relationships in Python

1. The Relationship Spectrum 📊

2. Breaking Down the 4 Relationships 🛠️

1. Dependency ("Uses-a")

2. Association ("Knows-a")

3. Aggregation ("Has-a" — Weak Ownership)

4. Composition ("Has-a" — Strong Ownership)

3. Practice Challenge: University Management System 🎓

Step 1: Initialize Your Workspace

Step 2: Implement university_system.py

Step 3: Run & Verify

Output Summary

#03 – The Power of Reuse: Inheritance & Polymorphism in Python

1. Inheritance Structures 🌳

2. Method Overriding & super() 🔄

🌱 Quick Example

3. Polymorphism & Duck Typing 🦆

4. Practice Challenge: Building an Employee Management System 🏢

Step 1: Initialize Your Workspace

Step 2: Implement employee_system.py

Step 3: Run & Verify Execution

Output Summary

#02 – Hiding Complexity: Encapsulation & Abstraction in Python

1. Access Modifiers: Public, Protected, & Private 🛡️

💻 Code Example: Access Modifiers & Name Mangling

2. Getters & Setters (@property) ⚙️

💻 Code Example: Controlled Access with @property

3. Abstraction & Abstract Base Classes (abc) 🎨

4. Practice Challenge: Design a Payment System 💳

Step 1: Initialize Your Workspace

Step 2: Implement payment_system.py

Step 3: Run & Verify

Output Summary

#01 – The Blueprint of Everything: Classes & Objects in Python

1. Classes, Objects, __init__, & self 🏛️

🌱 Easy Starter Example

🏛️ Real-World Example: User Session Identity Manager

2. Instance vs. Class Attributes ⚙️

🌱 Easy Starter Example

🏛️ Real-World Example: Product Pricing Engine with Tax Rates

3. Practice Challenge: Building User, Product, & BankAccount Classes 🏋️

Step 1: Initialize Your Workspace

Step 2: Implement domain_models.py

Step 3: Run & Verify Execution

Output Summary

#07 – Pythonic Code & Standard Library

1. Writing Pythonic Code & Type Hints 🐍

Type Hints & Modern Typing

2. Standard Library Powerhouses 🧰

A. The collections Module

B. The itertools Module

C. The functools Module

3. Core System Utilities (Time, Paths & Constants) 🌍

A. Dates & Time Zones (datetime)

B. Advanced File Automation (pathlib)

C. Readable Enumerations (Enum)

4. Modern Development Workflow Tools 🛠️

A. Ruff (The Modern Standard Linter & Formatter)

B. Basics of pytest

5. Practice Challenge: E-Commerce Metrics Engine 🏋️

Step 1: Initialize Your Workspace

Step 2: Implement the Main Business Logic

Step 3: Write Your Test Suite

Step 4: Validate Code Style and Run Tests

#06 – Advanced Python Features

1. Comprehensions 🧠

🌱 Easy Starter Example

1. Object Representation: `str` vs `repr`

2. Sizing & Comparisons: `len`, `eq`, `lt`

3. Iteration & Callables: `iter`, `call`

4. Context Management: `enter`, `exit`

3. Practice Challenge: Custom `SmartBatch` Pipeline 🚀

Step 2: Implement `smart_batch.py`

Step 2: Implement `university_system.py`

2. Method Overriding & `super()` 🔄

Step 2: Implement `employee_system.py`

2. Getters & Setters (`@property`) ⚙️

💻 Code Example: Controlled Access with `@property`

3. Abstraction & Abstract Base Classes (`abc`) 🎨

Step 2: Implement `payment_system.py`

1. Classes, Objects, `init`, & `self` 🏛️

Step 2: Implement `domain_models.py`

A. The `collections` Module

B. The `itertools` Module

C. The `functools` Module

A. Dates & Time Zones (`datetime`)

B. Advanced File Automation (`pathlib`)

C. Readable Enumerations (`Enum`)

B. Basics of `pytest`

Generators & `yield`

1. File Handling & `pathlib` 📄

🌱 Easy Starter Example: Isolate a package with `pip`

🏛️ Real-World Example: Modernized `uv` workflow