Method Implementation in Python

class Dog:
    def __init__(self, name, breed, age):
        self.name = name
        self.breed = breed
        self.age = age
        self.is_sitting = False
    
    def bark(self):
        """Make the dog bark."""
        return f"{self.name} says Woof!"
    
    def sit(self):
        """Make the dog sit down."""
        if self.is_sitting:
            return f"{self.name} is already sitting"
        else:
            self.is_sitting = True
            return f"{self.name} sits down"
    
    def stand(self):
        """Make the dog stand up."""
        if not self.is_sitting:
            return f"{self.name} is already standing"
        else:
            self.is_sitting = False
            return f"{self.name} stands up"
    
    def describe(self):
        """Return a description of the dog."""
        status = "sitting" if self.is_sitting else "standing"
        return f"{self.name} is a {self.age}-year-old {self.breed} who is currently {status}"

# Create a dog
buddy = Dog("Buddy", "Golden Retriever", 3)

# Call methods
print(buddy.bark())       # Output: Buddy says Woof!
print(buddy.sit())        # Output: Buddy sits down
print(buddy.sit())        # Output: Buddy is already sitting
print(buddy.describe())   # Output: Buddy is a 3-year-old Golden Retriever who is currently sitting
print(buddy.stand())      # Output: Buddy stands up

class MathUtil:
    # Class variable
    pi = 3.14159265359
    
    def __init__(self, value):
        # Instance variable
        self.value = value
    
    # Instance method - operates on instance data (self.value)
    def square(self):
        """Return the square of the instance's value."""
        return self.value ** 2
    
    # Class method - operates on class data (cls.pi)
    @classmethod
    def circle_area(cls, radius):
        """Calculate the area of a circle with the given radius."""
        return cls.pi * radius ** 2
    
    # Static method - doesn't operate on instance or class data
    @staticmethod
    def add(x, y):
        """Add two numbers."""
        return x + y

# Using the different method types
math = MathUtil(5)
print(math.square())                # Instance method: 25
print(MathUtil.circle_area(3))      # Class method: 28.27...
print(MathUtil.add(10, 20))         # Static method: 30
print(math.add(10, 20))             # Static methods can also be called on instances: 30

class ShoppingCart:
    def __init__(self):
        self.items = {}  # Dictionary to store items and quantities
    
    # Method with required parameters
    def add_item(self, item, price):
        """Add an item to the cart with quantity 1."""
        if item in self.items:
            self.items[item]['quantity'] += 1
        else:
            self.items[item] = {'price': price, 'quantity': 1}
        return f"Added {item} to cart"
    
    # Method with an optional parameter (default value)
    def update_quantity(self, item, quantity=1):
        """Update the quantity of an item in the cart."""
        if item not in self.items:
            return f"{item} not in cart"
        
        self.items[item]['quantity'] = quantity
        return f"Updated {item} quantity to {quantity}"
    
    # Method with variable arguments
    def add_multiple_items(self, *args, **kwargs):
        """Add multiple items to the cart.
        
        There are two ways to use this method:
        1. Pass (item, price) pairs as positional arguments: add_multiple_items("apple", 0.50, "banana", 0.30)
        2. Pass item=price keyword arguments: add_multiple_items(apple=0.50, banana=0.30)
        """
        # Process positional arguments (item, price pairs)
        if args:
            if len(args) % 2 != 0:
                return "Positional arguments must be (item, price) pairs"
            
            for i in range(0, len(args), 2):
                item, price = args[i], args[i+1]
                self.add_item(item, price)
        
        # Process keyword arguments (item=price)
        for item, price in kwargs.items():
            self.add_item(item, price)
        
        return f"Added {(len(args) // 2) + len(kwargs)} items to cart"
    
    def get_total(self):
        """Calculate the total price of all items in the cart."""
        total = 0
        for item, details in self.items.items():
            total += details['price'] * details['quantity']
        return total
    
    def display(self):
        """Display the cart contents."""
        if not self.items:
            return "Cart is empty"
        
        result = ["Shopping Cart:"]
        for item, details in self.items.items():
            subtotal = details['price'] * details['quantity']
            result.append(f"{item}: {details['quantity']} x ${details['price']:.2f} = ${subtotal:.2f}")
        
        result.append(f"Total: ${self.get_total():.2f}")
        return "\n".join(result)

# Using the ShoppingCart
cart = ShoppingCart()

# Required parameters
cart.add_item("apple", 0.50)
cart.add_item("banana", 0.30)

# Optional parameter (using default)
cart.add_item("orange", 0.75)
# Optional parameter (specifying a value)
cart.update_quantity("orange", 3)

# Variable arguments
cart.add_multiple_items("grapes", 2.50, "bread", 1.50)  # Positional
cart.add_multiple_items(milk=2.99, eggs=1.99)           # Keyword

# Display the cart
print(cart.display())

class DataProcessor:
    def __init__(self, data):
        self.data = data if data else []
    
    # Return a simple value (number)
    def count(self):
        """Return the number of items in the data."""
        return len(self.data)
    
    # Return a boolean
    def is_empty(self):
        """Check if the data is empty."""
        return len(self.data) == 0
    
    # Return a complex structure (list)
    def get_sorted(self):
        """Return a sorted copy of the data."""
        return sorted(self.data)
    
    # Return multiple values (as a tuple)
    def get_stats(self):
        """Return basic statistics about the data: min, max, sum, average."""
        if not self.data:
            return None, None, 0, None
        
        data_min = min(self.data)
        data_max = max(self.data)
        data_sum = sum(self.data)
        data_avg = data_sum / len(self.data)
        
        return data_min, data_max, data_sum, data_avg
    
    # Return different types based on conditions
    def get_element(self, index):
        """Get the element at the specified index, or None if out of bounds."""
        if 0 <= index < len(self.data):
            return self.data[index]
        return None
    
    # Method with no explicit return (implicitly returns None)
    def clear(self):
        """Clear all data."""
        self.data = []

# Using the DataProcessor
numbers = DataProcessor([5, 2, 8, 1, 9, 3])

# Simple return values
print(f"Count: {numbers.count()}")              # Output: Count: 6
print(f"Is empty: {numbers.is_empty()}")        # Output: Is empty: False

# Complex return value (list)
print(f"Sorted: {numbers.get_sorted()}")        # Output: Sorted: [1, 2, 3, 5, 8, 9]

# Multiple return values (tuple)
min_val, max_val, sum_val, avg_val = numbers.get_stats()
print(f"Min: {min_val}, Max: {max_val}, Sum: {sum_val}, Average: {avg_val:.2f}")
# Output: Min: 1, Max: 9, Sum: 28, Average: 4.67

# Conditional return
print(f"Element at index 2: {numbers.get_element(2)}")    # Output: Element at index 2: 8
print(f"Element at index 10: {numbers.get_element(10)}")  # Output: Element at index 10: None

# Method with no return value
numbers.clear()
print(f"After clearing - Count: {numbers.count()}")       # Output: After clearing - Count: 0

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.friends = []
    
    # Getters (retrieving values)
    def get_name(self):
        return self.name
    
    def get_age(self):
        return self.age
    
    # Setters (updating values)
    def set_name(self, name):
        self.name = name
    
    def set_age(self, age):
        if age < 0:
            raise ValueError("Age cannot be negative")
        self.age = age
    
    # Boolean methods (is_ or has_)
    def is_adult(self):
        return self.age >= 18
    
    def has_friends(self):
        return len(self.friends) > 0
    
    # Add/Remove methods
    def add_friend(self, friend_name):
        if friend_name not in self.friends:
            self.friends.append(friend_name)
            return f"{friend_name} added as a friend"
        return f"{friend_name} is already a friend"
    
    def remove_friend(self, friend_name):
        if friend_name in self.friends:
            self.friends.remove(friend_name)
            return f"{friend_name} removed from friends"
        return f"{friend_name} is not in friends list"
    
    # Calculation methods
    def calculate_birth_year(self, current_year):
        return current_year - self.age
    
    # Conversion methods
    def to_dict(self):
        return {
            "name": self.name,
            "age": self.age,
            "friends": self.friends
        }
    
    # Special methods
    def __str__(self):
        return f"{self.name}, {self.age} years old"
    
    def __repr__(self):
        return f"Person('{self.name}', {self.age})"

# Using the Person class
person = Person("Alice", 30)

# Using getters and setters
print(person.get_name())          # Output: Alice
person.set_age(32)
print(person.get_age())           # Output: 32

# Using boolean methods
print(person.is_adult())          # Output: True
print(person.has_friends())       # Output: False

# Using add/remove methods
print(person.add_friend("Bob"))   # Output: Bob added as a friend
print(person.add_friend("Carol")) # Output: Carol added as a friend
print(person.has_friends())       # Output: True
print(person.remove_friend("Bob")) # Output: Bob removed from friends

# Using calculation methods
print(person.calculate_birth_year(2023))  # Output: 1991

# Using conversion methods
print(person.to_dict())           # Output: {'name': 'Alice', 'age': 32, 'friends': ['Carol']}

# Using special methods
print(person)                     # Output: Alice, 32 years old
print(repr(person))               # Output: Person('Alice', 32)

class BankAccount:
    """A class representing a bank account."""
    
    def __init__(self, account_number, owner_name, balance=0):
        """Initialize a new bank account.
        
        Args:
            account_number (str): The account number.
            owner_name (str): The name of the account owner.
            balance (float, optional): The initial balance. Defaults to 0.
        
        Raises:
            ValueError: If the initial balance is negative.
        """
        if balance < 0:
            raise ValueError("Initial balance cannot be negative")
        
        self.account_number = account_number
        self.owner_name = owner_name
        self.balance = balance
        self.transactions = []
        
        # Record initial deposit if any
        if balance > 0:
            self.transactions.append(("deposit", balance))
    
    def deposit(self, amount):
        """Deposit money into the account.
        
        Args:
            amount (float): The amount to deposit.
            
        Returns:
            str: A confirmation message.
            
        Raises:
            ValueError: If the amount is not positive.
        """
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        
        self.balance += amount
        self.transactions.append(("deposit", amount))
        return f"Deposited ${amount:.2f}. New balance: ${self.balance:.2f}"
    
    def withdraw(self, amount):
        """Withdraw money from the account.
        
        Args:
            amount (float): The amount to withdraw.
            
        Returns:
            str: A confirmation message.
            
        Raises:
            ValueError: If the amount is not positive or exceeds the balance.
        """
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")
        
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        
        self.balance -= amount
        self.transactions.append(("withdrawal", amount))
        return f"Withdrew ${amount:.2f}. New balance: ${self.balance:.2f}"
    
    def get_balance(self):
        """Get the current account balance.
        
        Returns:
            float: The current balance.
        """
        return self.balance
    
    def get_transaction_history(self):
        """Get the account's transaction history.
        
        Returns:
            list: A list of tuples (transaction_type, amount).
        """
        return self.transactions.copy()
    
    def __str__(self):
        """Return a string representation of the account.
        
        Returns:
            str: A string describing the account.
        """
        return f"Account {self.account_number} owned by {self.owner_name}, Balance: ${self.balance:.2f}"

class Rectangle:
    """A class representing a rectangle."""
    
    def __init__(self, width=0, height=0):
        """Initialize a rectangle with the given width and height."""
        self.width = width
        self.height = height
    
    # Accessor methods (getters)
    def get_width(self):
        """Get the rectangle's width."""
        return self.width
    
    def get_height(self):
        """Get the rectangle's height."""
        return self.height
    
    def get_area(self):
        """Calculate and return the rectangle's area."""
        return self.width * self.height
    
    def get_perimeter(self):
        """Calculate and return the rectangle's perimeter."""
        return 2 * (self.width + self.height)
    
    # Mutator methods (setters)
    def set_width(self, width):
        """Set the rectangle's width."""
        if width < 0:
            raise ValueError("Width cannot be negative")
        self.width = width
        return self  # For method chaining
    
    def set_height(self, height):
        """Set the rectangle's height."""
        if height < 0:
            raise ValueError("Height cannot be negative")
        self.height = height
        return self  # For method chaining
    
    # Helper method (private by convention)
    def _is_square(self):
        """Check if the rectangle is a square."""
        return self.width == self.height
    
    # Method that uses the helper method
    def describe(self):
        """Return a description of the rectangle."""
        shape_name = "square" if self._is_square() else "rectangle"
        return f"A {shape_name} with width={self.width}, height={self.height}, area={self.get_area()}"
    
    # Factory method
    @classmethod
    def create_square(cls, side_length):
        """Create a square (a rectangle with equal sides)."""
        return cls(side_length, side_length)
    
    @classmethod
    def create_from_area(cls, area, width_height_ratio=1):
        """Create a rectangle with the given area and width/height ratio."""
        height = (area / width_height_ratio) ** 0.5
        width = height * width_height_ratio
        return cls(width, height)
    
    # Method chaining example
    def double_size(self):
        """Double both width and height."""
        self.width *= 2
        self.height *= 2
        return self  # Returning self allows method chaining

# Using accessor and mutator methods
rect = Rectangle(5, 3)
print(f"Width: {rect.get_width()}, Height: {rect.get_height()}")
print(f"Area: {rect.get_area()}, Perimeter: {rect.get_perimeter()}")

# Using a method that uses a helper method
print(rect.describe())  # Output: A rectangle with width=5, height=3, area=15

# Using factory methods
square = Rectangle.create_square(4)
print(square.describe())  # Output: A square with width=4, height=4, area=16

custom_rect = Rectangle.create_from_area(50, 2)  # Width is twice the height
print(custom_rect.describe())
print(f"Dimensions: {custom_rect.get_width():.2f} x {custom_rect.get_height():.2f}")

# Using method chaining
rect.set_width(2).set_height(6)
print(rect.describe())  # Output: A rectangle with width=2, height=6, area=12

rect.double_size().double_size()
print(rect.describe())  # Output: A rectangle with width=8, height=24, area=192

class Vector:
    """A class representing a 2D vector."""
    
    def __init__(self, x, y):
        """Initialize a vector with x and y components."""
        self.x = x
        self.y = y
    
    # String representation methods
    def __str__(self):
        """Return a user-friendly string representation."""
        return f"Vector({self.x}, {self.y})"
    
    def __repr__(self):
        """Return a developer-friendly string representation."""
        return f"Vector({self.x}, {self.y})"
    
    # Comparison methods
    def __eq__(self, other):
        """Check if two vectors are equal."""
        if not isinstance(other, Vector):
            return NotImplemented
        return self.x == other.x and self.y == other.y
    
    def __lt__(self, other):
        """Compare vectors based on their magnitude."""
        if not isinstance(other, Vector):
            return NotImplemented
        return self.magnitude() < other.magnitude()
    
    # Arithmetic methods
    def __add__(self, other):
        """Add two vectors."""
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x + other.x, self.y + other.y)
    
    def __sub__(self, other):
        """Subtract another vector from this one."""
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x - other.x, self.y - other.y)
    
    def __mul__(self, scalar):
        """Multiply the vector by a scalar."""
        if not isinstance(scalar, (int, float)):
            return NotImplemented
        return Vector(self.x * scalar, self.y * scalar)
    
    def __rmul__(self, scalar):
        """Handle scalar multiplication when the scalar is on the left."""
        return self.__mul__(scalar)
    
    # Unary operators
    def __neg__(self):
        """Negate the vector."""
        return Vector(-self.x, -self.y)
    
    def __abs__(self):
        """Return the magnitude of the vector."""
        return self.magnitude()
    
    # Length method
    def __len__(self):
        """Return the magnitude rounded to the nearest integer."""
        return round(self.magnitude())
    
    # Container methods
    def __getitem__(self, index):
        """Allow indexing: vector[0] returns x, vector[1] returns y."""
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            raise IndexError("Vector index out of range")
    
    # Other methods
    def magnitude(self):
        """Calculate the magnitude (length) of the vector."""
        return (self.x**2 + self.y**2)**0.5
    
    def dot(self, other):
        """Calculate the dot product with another vector."""
        if not isinstance(other, Vector):
            raise TypeError("Dot product requires another Vector")
        return self.x * other.x + self.y * other.y

# Creating vectors
v1 = Vector(3, 4)
v2 = Vector(1, 2)

# String representation
print(v1)  # Uses __str__
print(repr(v2))  # Uses __repr__

# Comparison
print(v1 == Vector(3, 4))  # True, uses __eq__
print(v1 != v2)  # True, uses __eq__
print(v1 < v2)  # False, uses __lt__ (v1 has greater magnitude)

# Arithmetic
v3 = v1 + v2  # Uses __add__
print(v3)  # Vector(4, 6)

v4 = v1 - v2  # Uses __sub__
print(v4)  # Vector(2, 2)

v5 = v1 * 2  # Uses __mul__
print(v5)  # Vector(6, 8)

v6 = 3 * v2  # Uses __rmul__
print(v6)  # Vector(3, 6)

# Unary operators
v7 = -v1  # Uses __neg__
print(v7)  # Vector(-3, -4)

# Built-in functions
print(abs(v1))  # 5.0, uses __abs__
print(len(v1))  # 5, uses __len__

# Indexing
print(v1[0])  # 3, uses __getitem__
print(v1[1])  # 4, uses __getitem__

# Regular methods
print(v1.magnitude())  # 5.0
print(v1.dot(v2))  # 11

class BankAccount:
    """A class representing a bank account."""
    
    minimum_balance = 100  # Minimum balance required
    
    def __init__(self, account_number, owner_name, balance=0):
        """Initialize a new bank account."""
        # Input validation
        if not isinstance(account_number, str):
            raise TypeError("Account number must be a string")
        
        if balance < 0:
            raise ValueError("Initial balance cannot be negative")
        
        self.account_number = account_number
        self.owner_name = owner_name
        self.balance = balance
    
    def deposit(self, amount):
        """Deposit money into the account."""
        # Input validation
        if not isinstance(amount, (int, float)):
            raise TypeError("Amount must be a number")
        
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        
        # Processing
        try:
            self.balance += amount
            return f"Deposited ${amount:.2f}. New balance: ${self.balance:.2f}"
        except Exception as e:
            # Handle unexpected errors
            return f"Error during deposit: {str(e)}"
    
    def withdraw(self, amount):
        """Withdraw money from the account."""
        # Input validation
        if not isinstance(amount, (int, float)):
            raise TypeError("Amount must be a number")
        
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")
        
        # Business logic validation
        if self.balance - amount < self.minimum_balance:
            raise ValueError(f"Withdrawal would put account below minimum balance of ${self.minimum_balance}")
        
        # Processing
        try:
            self.balance -= amount
            return f"Withdrew ${amount:.2f}. New balance: ${self.balance:.2f}"
        except Exception as e:
            # Handle unexpected errors
            return f"Error during withdrawal: {str(e)}"
    
    def transfer(self, target_account, amount):
        """Transfer money to another account."""
        # Input validation
        if not isinstance(target_account, BankAccount):
            raise TypeError("Target must be a BankAccount")
        
        # Use a try-except block to ensure atomicity (all-or-nothing)
        try:
            # First withdraw from this account (might raise an exception)
            withdrawal_result = self.withdraw(amount)
            
            # Then deposit to the target account
            target_account.deposit(amount)
            
            return f"Transferred ${amount:.2f} to account {target_account.account_number}"
        except Exception as e:
            # If anything goes wrong, don't complete the transfer
            return f"Transfer failed: {str(e)}"
    
    def get_balance(self):
        """Get the current account balance."""
        return self.balance

# Using the BankAccount with error handling
try:
    # Create accounts
    account1 = BankAccount("12345", "Alice", 500)
    account2 = BankAccount("67890", "Bob", 300)
    
    # Successful operations
    print(account1.deposit(200))
    print(account1.transfer(account2, 100))
    
    # Operations with errors
    try:
        print(account1.withdraw(1000))  # Would go below minimum balance
    except ValueError as e:
        print(f"Error: {e}")
    
    try:
        print(account1.deposit(-50))  # Negative amount
    except ValueError as e:
        print(f"Error: {e}")
    
    try:
        print(account1.transfer("not an account", 100))  # Wrong type
    except TypeError as e:
        print(f"Error: {e}")
    
except Exception as e:
    print(f"Unexpected error: {e}")

class Circle:
    """A class representing a circle."""
    
    def __init__(self, radius):
        """Initialize a circle with the given radius."""
        self._radius = None  # Using a private attribute
        self.radius = radius  # This calls the radius setter
    
    @property
    def radius(self):
        """Get the circle's radius."""
        return self._radius
    
    @radius.setter
    def radius(self, value):
        """Set the circle's radius with validation."""
        if not isinstance(value, (int, float)):
            raise TypeError("Radius must be a number")
        
        if value <= 0:
            raise ValueError("Radius must be positive")
        
        self._radius = value
    
    @property
    def diameter(self):
        """Calculate the circle's diameter."""
        return self.radius * 2
    
    @diameter.setter
    def diameter(self, value):
        """Set the circle's diameter."""
        self.radius = value / 2  # This calls the radius setter for validation
    
    @property
    def area(self):
        """Calculate the circle's area."""
        import math
        return math.pi * self.radius ** 2
    
    @property
    def circumference(self):
        """Calculate the circle's circumference."""
        import math
        return 2 * math.pi * self.radius

# Using the Circle class with properties
circle = Circle(5)

# Properties are accessed like attributes
print(f"Radius: {circle.radius}")
print(f"Diameter: {circle.diameter}")
print(f"Area: {circle.area:.2f}")
print(f"Circumference: {circle.circumference:.2f}")

# Properties can also be set like attributes (if they have setters)
circle.radius = 7
print(f"New radius: {circle.radius}")
print(f"New diameter: {circle.diameter}")

circle.diameter = 20
print(f"After setting diameter - Radius: {circle.radius}")
print(f"After setting diameter - Area: {circle.area:.2f}")

# But they include validation
try:
    circle.radius = -10  # This will raise an exception
except ValueError as e:
    print(f"Error: {e}")

# Read-only properties can't be set
try:
    circle.area = 100  # This will raise an AttributeError
except AttributeError as e:
    print(f"Error: {e}")

class Shape:
    """Base class for geometric shapes."""
    
    def __init__(self, color="white"):
        """Initialize a shape with the given color."""
        self.color = color
    
    def area(self):
        """Calculate the shape's area. Should be overridden by subclasses."""
        raise NotImplementedError("Subclasses must implement area()")
    
    def perimeter(self):
        """Calculate the shape's perimeter. Should be overridden by subclasses."""
        raise NotImplementedError("Subclasses must implement perimeter()")
    
    def describe(self):
        """Return a description of the shape."""
        return f"A {self.color} shape"

class Circle(Shape):
    """A circle shape."""
    
    def __init__(self, radius, color="white"):
        """Initialize a circle with the given radius and color."""
        super().__init__(color)  # Call the parent's __init__
        self.radius = radius
    
    def area(self):
        """Calculate the circle's area."""
        import math
        return math.pi * self.radius ** 2
    
    def perimeter(self):
        """Calculate the circle's perimeter (circumference)."""
        import math
        return 2 * math.pi * self.radius
    
    def describe(self):
        """Return a description of the circle. Overrides Shape.describe()."""
        return f"A {self.color} circle with radius {self.radius}"

class Rectangle(Shape):
    """A rectangle shape."""
    
    def __init__(self, width, height, color="white"):
        """Initialize a rectangle with the given width, height, and color."""
        super().__init__(color)  # Call the parent's __init__
        self.width = width
        self.height = height
    
    def area(self):
        """Calculate the rectangle's area."""
        return self.width * self.height
    
    def perimeter(self):
        """Calculate the rectangle's perimeter."""
        return 2 * (self.width + self.height)
    
    def describe(self):
        """Return a description of the rectangle. Overrides Shape.describe()."""
        return f"A {self.color} rectangle with width {self.width} and height {self.height}"

class Square(Rectangle):
    """A square shape (a special kind of rectangle)."""
    
    def __init__(self, side_length, color="white"):
        """Initialize a square with the given side length and color."""
        super().__init__(side_length, side_length, color)  # A square is a rectangle with equal sides
    
    def describe(self):
        """Return a description of the square. Overrides Rectangle.describe()."""
        return f"A {self.color} square with side length {self.width}"

# Function that works with any Shape
def print_shape_info(shape):
    """Print information about a shape."""
    print(shape.describe())
    print(f"Area: {shape.area():.2f}")
    print(f"Perimeter: {shape.perimeter():.2f}")
    print()

# Create different shapes
circle = Circle(5, "red")
rectangle = Rectangle(4, 6, "blue")
square = Square(3, "green")

# Use polymorphism through the common interface
shapes = [circle, rectangle, square]
for shape in shapes:
    print_shape_info(shape)

class A:
    def method(self):
        return "Method from A"

class B(A):
    def method(self):
        return "Method from B"

class C(A):
    def method(self):
        return "Method from C"

class D(B, C):
    pass  # No method override

# Creating an instance of D
d = D()

# Which method implementation will be called?
print(d.method())  # Output: Method from B

# Examining the MRO
print(D.__mro__)
# Output: (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

# The MRO determines the search order for methods:
# 1. D (no method found)
# 2. B (method found here, so it's used)
# 3. C (not searched because B's method is used)
# 4. A (not searched because B's method is used)
# 5. object (not searched because B's method is used)

class Vehicle:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.is_running = False
    
    def start(self):
        if not self.is_running:
            self.is_running = True
            return f"{self.make} {self.model} started"
        return f"{self.make} {self.model} is already running"
    
    def stop(self):
        if self.is_running:
            self.is_running = False
            return f"{self.make} {self.model} stopped"
        return f"{self.make} {self.model} is already stopped"
    
    def honk(self):
        return "Beep!"
    
    def describe(self):
        status = "running" if self.is_running else "not running"
        return f"{self.year} {self.make} {self.model} ({status})"

class Car(Vehicle):
    def __init__(self, make, model, year, fuel_type="gasoline"):
        super().__init__(make, model, year)
        self.fuel_type = fuel_type
        self.gear = "park"
    
    def shift_gear(self, gear):
        allowed_gears = ["park", "reverse", "neutral", "drive"]
        if gear.lower() not in allowed_gears:
            return f"Invalid gear: {gear}"
        
        self.gear = gear.lower()
        return f"Shifted to {self.gear}"
    
    def describe(self):
        # Use super() to get the parent's description and add to it
        base_description = super().describe()
        return f"{base_description}, {self.fuel_type} fuel, in {self.gear} gear"
    
    def honk(self):
        # Override honk with custom sound
        return "Honk! Honk!"

class ElectricCar(Car):
    def __init__(self, make, model, year, battery_capacity):
        # Pass "electric" as the fuel type to the parent
        super().__init__(make, model, year, "electric")
        self.battery_capacity = battery_capacity
        self.battery_level = 100  # Percent
    
    def start(self):
        # Collaborative override: check battery before starting
        if self.battery_level < 5:
            return f"{self.make} {self.model} cannot start: Battery too low"
        
        # Call parent's start method
        return super().start() + " (silently)"
    
    def describe(self):
        # Build on the parent's description
        base_description = super().describe()
        return f"{base_description}, battery: {self.battery_level}%"

# Create and use vehicles
regular_car = Car("Toyota", "Corolla", 2020)
tesla = ElectricCar("Tesla", "Model 3", 2021, 75)

# Test the collaborative methods
print(regular_car.describe())
regular_car.start()
regular_car.shift_gear("drive")
print(regular_car.describe())
print(regular_car.honk())

print("\n" + "="*50 + "\n")

print(tesla.describe())
tesla.start()
tesla.shift_gear("drive")
print(tesla.describe())

# Test low battery scenario
tesla.battery_level = 3
print(tesla.start())

class Product:
              """A class representing a product in an e-commerce system."""
              
              # Class variable to track all products
              all_products = {}
              
              def __init__(self, product_id, name, price, category, stock=0):
                  """Initialize a new product."""
                  # Validate inputs
                  if not isinstance(price, (int, float)) or price < 0:
                      raise ValueError("Price must be a non-negative number")
                  
                  if not isinstance(stock, int) or stock < 0:
                      raise ValueError("Stock must be a non-negative integer")
                  
                  # Set instance attributes
                  self.product_id = product_id
                  self.name = name
                  self.price = price
                  self.category = category
                  self.stock = stock
                  
                  # Register the product in the class dictionary
                  Product.all_products[product_id] = self
              
              # Instance methods
              def update_stock(self, quantity):
                  """Update the product's stock level."""
                  new_stock = self.stock + quantity
                  if new_stock < 0:
                      raise ValueError("Cannot reduce stock below zero")
                  
                  self.stock = new_stock
                  return f"{self.name} stock updated to {self.stock}"
              
              def is_available(self):
                  """Check if the product is in stock."""
                  return self.stock > 0
              
              def apply_discount(self, percent):
                  """Apply a discount to the product's price."""
                  if not 0 <= percent <= 100:
                      raise ValueError("Discount percentage must be between 0 and 100")
                  
                  discount_amount = (percent / 100) * self.price
                  self.price -= discount_amount
                  return f"{self.name} price discounted by {percent}% to ${self.price:.2f}"
              
              # Special methods
              def __str__(self):
                  """Return a string representation of the product."""
                  status = "In Stock" if self.stock > 0 else "Out of Stock"
                  return f"{self.name} (${self.price:.2f}) - {status}"
              
              # Class methods
              @classmethod
              def find_by_id(cls, product_id):
                  """Find a product by its ID."""
                  return cls.all_products.get(product_id)
              
              @classmethod
              def find_by_category(cls, category):
                  """Find all products in a specific category."""
                  return [product for product in cls.all_products.values() 
                          if product.category.lower() == category.lower()]
              
              # Static method
              @staticmethod
              def format_currency(amount):
                  """Format a number as a currency string."""
                  return f"${amount:.2f}"
          
          
          class ShoppingCart:
              """A class representing a shopping cart."""
              
              def __init__(self, customer_name):
                  """Initialize a new shopping cart."""
                  self.customer_name = customer_name
                  self.items = {}  # Dictionary to store product_id: quantity
              
              def add_item(self, product, quantity=1):
                  """Add a product to the cart."""
                  # Validate inputs
                  if not isinstance(product, Product):
                      raise TypeError("Product must be a Product object")
                  
                  if not isinstance(quantity, int) or quantity <= 0:
                      raise ValueError("Quantity must be a positive integer")
                  
                  # Check if product is available
                  if not product.is_available():
                      return f"{product.name} is out of stock"
                  
                  # Check if there's enough stock
                  if product.stock < quantity:
                      return f"Not enough stock for {product.name}. Available: {product.stock}"
                  
                  # Add to cart
                  if product.product_id in self.items:
                      self.items[product.product_id] += quantity
                  else:
                      self.items[product.product_id] = quantity
                  
                  return f"Added {quantity} x {product.name} to cart"
              
              def remove_item(self, product, quantity=None):
                  """Remove a product from the cart."""
                  if not isinstance(product, Product):
                      raise TypeError("Product must be a Product object")
                  
                  if product.product_id not in self.items:
                      return f"{product.name} not in cart"
                  
                  if quantity is None or quantity >= self.items[product.product_id]:
                      # Remove all of this product
                      del self.items[product.product_id]
                      return f"Removed {product.name} from cart"
                  else:
                      # Remove specified quantity
                      self.items[product.product_id] -= quantity
                      return f"Removed {quantity} x {product.name} from cart"
              
              def get_total(self):
                  """Calculate the total price of the cart."""
                  total = 0
                  for product_id, quantity in self.items.items():
                      product = Product.find_by_id(product_id)
                      if product:
                          total += product.price * quantity
                  return total
              
              def clear(self):
                  """Remove all items from the cart."""
                  self.items = {}
                  return f"{self.customer_name}'s cart has been cleared"
              
              def checkout(self):
                  """Process the checkout, updating product stock."""
                  if not self.items:
                      return "Cart is empty"
                  
                  # Check if all products are still available
                  for product_id, quantity in self.items.items():
                      product = Product.find_by_id(product_id)
                      if not product:
                          return f"Product with ID {product_id} no longer exists"
                      
                      if product.stock < quantity:
                          return f"Not enough stock for {product.name}. Available: {product.stock}"
                  
                  # Process the purchase by updating stock
                  order_summary = [f"Order for {self.customer_name}:"]
                  for product_id, quantity in self.items.items():
                      product = Product.find_by_id(product_id)
                      product.update_stock(-quantity)  # Reduce stock
                      order_summary.append(f"- {quantity} x {product.name} @ {Product.format_currency(product.price)} each")
                  
                  # Add total to order summary
                  total = self.get_total()
                  order_summary.append(f"Total: {Product.format_currency(total)}")
                  
                  # Clear the cart
                  self.clear()
                  
                  return "\n".join(order_summary)
              
              def __str__(self):
                  """Return a string representation of the cart."""
                  if not self.items:
                      return f"{self.customer_name}'s cart is empty"
                  
                  cart_items = []
                  for product_id, quantity in self.items.items():
                      product = Product.find_by_id(product_id)
                      if product:
                          item_total = product.price * quantity
                          cart_items.append(f"{quantity} x {product.name} @ {Product.format_currency(product.price)} = {Product.format_currency(item_total)}")
                  
                  cart_summary = [f"{self.customer_name}'s Shopping Cart:"]
                  cart_summary.extend(cart_items)
                  cart_summary.append(f"Total: {Product.format_currency(self.get_total())}")
                  
                  return "\n".join(cart_summary)
          
          
          class DiscountedProduct(Product):
              """A product with special discounting capabilities."""
              
              def __init__(self, product_id, name, price, category, discount_percent=0, stock=0):
                  """Initialize a discounted product."""
                  # Call the parent's __init__
                  super().__init__(product_id, name, price, category, stock)
                  
                  # Additional attributes
                  self._discount_percent = 0  # Use property setter
                  self.discount_percent = discount_percent  # Validate and set discount
                  self.original_price = price  # Store original price
              
              @property
              def discount_percent(self):
                  """Get the discount percentage."""
                  return self._discount_percent
              
              @discount_percent.setter
              def discount_percent(self, value):
                  """Set the discount percentage and update the price."""
                  if not isinstance(value, (int, float)):
                      raise TypeError("Discount percentage must be a number")
                  
                  if not 0 <= value <= 100:
                      raise ValueError("Discount percentage must be between 0 and 100")
                  
                  # If discount is changing, update price
                  if value != self._discount_percent:
                      self._discount_percent = value
                      
                      # Reset price to original and apply new discount
                      self.price = self.original_price * (1 - value / 100)
              
              def apply_discount(self, percent):
                  """Override the parent's apply_discount method."""
                  # Instead of applying an additional discount, update the discount property
                  self.discount_percent = percent
                  return f"{self.name} price discounted by {percent}% to ${self.price:.2f}"
              
              def reset_discount(self):
                  """Reset the product to its original price."""
                  old_price = self.price
                  self.discount_percent = 0
                  return f"{self.name} price reset from ${old_price:.2f} to ${self.price:.2f}"
              
              def __str__(self):
                  """Override the parent's __str__ method."""
                  status = "In Stock" if self.stock > 0 else "Out of Stock"
                  if self.discount_percent > 0:
                      return f"{self.name} (${self.price:.2f}, {self.discount_percent}% off) - {status}"
                  else:
                      return f"{self.name} (${self.price:.2f}) - {status}"
          
          
          # Using the e-commerce system
          
          # Create some products
          headphones = Product("P001", "Wireless Headphones", 99.99, "Electronics", 10)
          laptop = Product("P002", "Laptop", 1299.99, "Electronics", 5)
          t_shirt = Product("P003", "T-Shirt", 19.99, "Clothing", 50)
          discounted_phone = DiscountedProduct("P004", "Smartphone", 699.99, "Electronics", 15, 8)
          
          # Find products by category
          electronics = Product.find_by_category("Electronics")
          print(f"Electronics products: {len(electronics)}")
          for product in electronics:
              print(f"- {product}")
          
          # Shopping cart operations
          cart = ShoppingCart("Alice")
          print(cart.add_item(headphones, 2))
          print(cart.add_item(laptop))
          print(cart.add_item(discounted_phone))
          
          # Display cart
          print("\n" + str(cart) + "\n")
          
          # Update product stock and check availability
          laptop.update_stock(-3)
          print(f"{laptop.name} availability: {laptop.is_available()}")
          
          # Remove an item from the cart
          print(cart.remove_item(headphones, 1))
          
          # Apply a discount to a product
          print(headphones.apply_discount(10))
          
          # Update discount on discounted product
          print(discounted_phone.discount_percent)
          print(discounted_phone.apply_discount(25))
          print(discounted_phone.discount_percent)
          
          # Checkout
          print("\n" + cart.checkout() + "\n")
          
          # Cart should be empty after checkout
          print(cart)

class LibraryMember:
              def __init__(self, member_id, name):
                  self.member_id = member_id
                  self.name = name
                  self.borrowed_books = []
              
              def borrow_book(self, book):
                  """Borrow a book by delegating to the book's checkout method."""
                  result = book.checkout(self.member_id)
                  if book.is_checked_out:
                      self.borrowed_books.append(book)
                  return result
          
          class Book:
              def __init__(self, title, author, isbn):
                  self.title = title
                  self.author = author
                  self.isbn = isbn
                  self.is_checked_out = False
                  self.borrower_id = None
              
              def checkout(self, member_id):
                  """Process a checkout request."""
                  if self.is_checked_out:
                      return f"{self.title} is already checked out"
                  
                  self.is_checked_out = True
                  self.borrower_id = member_id
                  return f"{self.title} has been checked out"

class DatabaseConnection:
              def __init__(self, host, username, password):
                  self.host = host
                  self.username = username
                  self.password = password
                  self._connection = None  # Not created yet
              
              def get_connection(self):
                  """Lazily initialize the database connection."""
                  if self._connection is None:
                      print(f"Connecting to database at {self.host}...")
                      # In a real implementation, this would use a DB library
                      self._connection = f"Connection to {self.host} as {self.username}"
                  
                  return self._connection

class QueryBuilder:
              def __init__(self):
                  self.table = None
                  self.columns = ["*"]
                  self.filters = []
                  self.order_by = None
                  self.limit_value = None
              
              def select(self, *columns):
                  """Specify columns to select."""
                  if columns:
                      self.columns = columns
                  return self  # Return self for chaining
              
              def from_table(self, table):
                  """Specify the table to query."""
                  self.table = table
                  return self
              
              def where(self, condition):
                  """Add a WHERE condition."""
                  self.filters.append(condition)
                  return self
              
              def order_by(self, column, descending=False):
                  """Specify ordering."""
                  direction = "DESC" if descending else "ASC"
                  self.order_by = f"{column} {direction}"
                  return self
              
              def limit(self, count):
                  """Specify a limit."""
                  self.limit_value = count
                  return self
              
              def build(self):
                  """Build and return the SQL query string."""
                  if not self.table:
                      raise ValueError("Table must be specified")
                  
                  query = f"SELECT {', '.join(self.columns)} FROM {self.table}"
                  
                  if self.filters:
                      query += f" WHERE {' AND '.join(self.filters)}"
                  
                  if self.order_by:
                      query += f" ORDER BY {self.order_by}"
                  
                  if self.limit_value:
                      query += f" LIMIT {self.limit_value}"
                  
                  return query
          
          # Using the fluent interface
          query = QueryBuilder() \
              .select("id", "name", "price") \
              .from_table("products") \
              .where("category = 'Electronics'") \
              .where("price < 1000") \
              .order_by("price", descending=True) \
              .limit(10) \
              .build()
          
          print(query)
          # Output: SELECT id, name, price FROM products WHERE category = 'Electronics' AND price < 1000 ORDER BY price DESC LIMIT 10

class ReportGenerator:
              """Base class for report generators."""
              
              def generate_report(self, data):
                  """Template method that defines the report generation algorithm."""
                  # Steps that are the same for all report types
                  processed_data = self.process_data(data)
                  report = self.format_header()
                  report += self.format_body(processed_data)
                  report += self.format_footer()
                  
                  return report
              
              def process_data(self, data):
                  """Process the data before formatting. Can be overridden."""
                  return data
              
              def format_header(self):
                  """Format the report header. Must be overridden."""
                  raise NotImplementedError("Subclasses must implement format_header()")
              
              def format_body(self, data):
                  """Format the report body. Must be overridden."""
                  raise NotImplementedError("Subclasses must implement format_body()")
              
              def format_footer(self):
                  """Format the report footer. Must be overridden."""
                  raise NotImplementedError("Subclasses must implement format_footer()")
          
          
          class TextReportGenerator(ReportGenerator):
              """Generates text-based reports."""
              
              def __init__(self, title):
                  self.title = title
              
              def format_header(self):
                  """Format the text report header."""
                  header = f"{self.title}\n"
                  header += "=" * len(self.title) + "\n\n"
                  return header
              
              def format_body(self, data):
                  """Format the text report body."""
                  body = ""
                  for item in data:
                      body += f"- {item}\n"
                  return body
              
              def format_footer(self):
                  """Format the text report footer."""
                  import datetime
                  now = datetime.datetime.now()
                  return f"\nReport generated on {now.strftime('%Y-%m-%d %H:%M')}"
          
          
          class HTMLReportGenerator(ReportGenerator):
              """Generates HTML-based reports."""
              
              def __init__(self, title):
                  self.title = title
              
              def process_data(self, data):
                  """Process data, filtering out any empty items."""
                  return [item for item in data if item.strip()]
              
              def format_header(self):
                  """Format the HTML report header."""
                  return f"<!DOCTYPE html>\n<html>\n<head>\n    <title>{self.title}</title>\n</head>\n<body>\n    <h1>{self.title}</h1>\n    <ul>\n"
              
              def format_body(self, data):
                  """Format the HTML report body."""
                  body = ""
                  for item in data:
                      body += f"        <li>{item}</li>\n"
                  return body
              
              def format_footer(self):
                  """Format the HTML report footer."""
                  import datetime
                  now = datetime.datetime.now()
                  footer = f"    </ul>\n    <p>Report generated on {now.strftime('%Y-%m-%d %H:%M')}</p>\n</body>\n</html>"
                  return footer
          
          # Sample data
          items = ["Apple", "Banana", "Cherry", "", "Elderberry"]
          
          # Generate text report
          text_generator = TextReportGenerator("Fruit Inventory")
          text_report = text_generator.generate_report(items)
          print(text_report)
          
          print("\n" + "="*50 + "\n")
          
          # Generate HTML report
          html_generator = HTMLReportGenerator("Fruit Inventory")
          html_report = html_generator.generate_report(items)
          print(html_report)

class Fibonacci:
              """Class for calculating Fibonacci numbers efficiently."""
              
              def __init__(self):
                  """Initialize with a cache for previously calculated values."""
                  self._cache = {0: 0, 1: 1}  # Base cases
              
              def calculate(self, n):
                  """Calculate the nth Fibonacci number with memoization."""
                  if n < 0:
                      raise ValueError("n must be non-negative")
                  
                  # Check if the value is in the cache
                  if n in self._cache:
                      return self._cache[n]
                  
                  # Calculate and cache the value
                  result = self.calculate(n-1) + self.calculate(n-2)
                  self._cache[n] = result
                  
                  return result
          
          # Using the memoization method
          fib = Fibonacci()
          print(f"Fibonacci(10) = {fib.calculate(10)}")
          print(f"Fibonacci(50) = {fib.calculate(50)}")  # Would be very slow without memoization

import time
          import functools
          
          # Define decorators
          def timer(func):
              """Decorator that times method execution."""
              @functools.wraps(func)
              def wrapper(*args, **kwargs):
                  start_time = time.time()
                  result = func(*args, **kwargs)
                  end_time = time.time()
                  print(f"{func.__name__} took {end_time - start_time:.6f} seconds to run")
                  return result
              return wrapper
          
          def log_calls(func):
              """Decorator that logs method calls."""
              @functools.wraps(func)
              def wrapper(*args, **kwargs):
                  print(f"Calling {func.__name__} with args: {args[1:]} and kwargs: {kwargs}")
                  result = func(*args, **kwargs)
                  print(f"{func.__name__} returned: {result}")
                  return result
              return wrapper
          
          # Apply decorators to methods
          class MathOperations:
              @timer
              def factorial(self, n):
                  """Calculate the factorial of n."""
                  if n < 0:
                      raise ValueError("n must be non-negative")
                  
                  result = 1
                  for i in range(2, n + 1):
                      result *= i
                  
                  return result
              
              @log_calls
              def power(self, base, exponent):
                  """Calculate base raised to the power of exponent."""
                  return base ** exponent
              
              @timer
              @log_calls
              def fibonacci(self, n):
                  """Calculate the nth Fibonacci number (inefficient implementation)."""
                  if n < 0:
                      raise ValueError("n must be non-negative")
                  
                  if n <= 1:
                      return n
                  
                  return self.fibonacci(n-1) + self.fibonacci(n-2)
          
          # Using decorated methods
          math = MathOperations()
          print(f"Factorial of 5: {math.factorial(5)}")
          print(f"2^10: {math.power(2, 10)}")
          print(f"Fibonacci(10): {math.fibonacci(10)}")  # This will be slow and show lots of logs

class DatabaseConnection:
              """A database connection that can be used as a context manager."""
              
              def __init__(self, connection_string):
                  self.connection_string = connection_string
                  self.connection = None
              
              def __enter__(self):
                  """Set up the connection when entering a with block."""
                  print(f"Connecting to {self.connection_string}...")
                  # In a real implementation, this would use a DB library
                  self.connection = f"Connection to {self.connection_string}"
                  return self
              
              def __exit__(self, exc_type, exc_val, exc_tb):
                  """Close the connection when exiting a with block."""
                  print(f"Closing connection to {self.connection_string}")
                  self.connection = None
                  
                  # If we return True, exceptions are suppressed
                  # If we return False or None, exceptions are propagated
                  return False  # Let exceptions propagate
              
              def execute_query(self, query):
                  """Execute a database query."""
                  if not self.connection:
                      raise RuntimeError("Connection is not established")
                  
                  print(f"Executing query: {query}")
                  return f"Results for {query}"
          
          # Using a context manager
          try:
              with DatabaseConnection("db://example.com/mydb") as db:
                  result = db.execute_query("SELECT * FROM users")
                  print(result)
                  
                  # This will raise an exception
                  if "error" in result:
                      raise ValueError("Query error")
              
              # The connection is automatically closed when exiting the with block
              
          except ValueError as e:
              print(f"Caught an error: {e}")
              # The connection is still properly closed!

class DataProcessor:
              """A class for processing large datasets efficiently."""
              
              def __init__(self, data):
                  self.data = data
              
              def filter_values(self, predicate):
                  """Generate values that satisfy the predicate."""
                  for item in self.data:
                      if predicate(item):
                          yield item
              
              def transform_values(self, transformer):
                  """Generate transformed values."""
                  for item in self.data:
                      yield transformer(item)
              
              def process_in_chunks(self, chunk_size):
                  """Generate chunks of the data."""
                  for i in range(0, len(self.data), chunk_size):
                      yield self.data[i:i+chunk_size]
          
          # Using generator methods
          data = list(range(1, 101))  # Numbers 1 to 100
          processor = DataProcessor(data)
          
          # Filter for even numbers
          even_numbers = processor.filter_values(lambda x: x % 2 == 0)
          print("First 5 even numbers:")
          for i, num in enumerate(even_numbers):
              if i >= 5:
                  break
              print(num, end=" ")
          print()
          
          # Transform values
          squares = processor.transform_values(lambda x: x**2)
          print("First 5 squares:")
          for i, num in enumerate(squares):
              if i >= 5:
                  break
              print(num, end=" ")
          print()
          
          # Process in chunks
          chunks = processor.process_in_chunks(10)
          print("First 3 chunks:")
          for i, chunk in enumerate(chunks):
              if i >= 3:
                  break
              print(chunk)

from functools import singledispatchmethod
          
          class Formatter:
              """A class that can format different types of data."""
              
              @singledispatchmethod
              def format(self, arg):
                  """Default implementation for unknown types."""
                  return f"Unknown type: {type(arg).__name__}"
              
              @format.register
              def _(self, arg: int):
                  """Format integers."""
                  return f"Integer: {arg:,d}"
              
              @format.register
              def _(self, arg: float):
                  """Format floats."""
                  return f"Float: {arg:.2f}"
              
              @format.register
              def _(self, arg: str):
                  """Format strings."""
                  return f"String: '{arg}'"
              
              @format.register
              def _(self, arg: list):
                  """Format lists."""
                  return f"List with {len(arg)} items: {arg}"
              
              @format.register
              def _(self, arg: dict):
                  """Format dictionaries."""
                  return f"Dict with {len(arg)} keys: {arg}"
          
          # Using the singledispatch method
          formatter = Formatter()
          print(formatter.format(42))
          print(formatter.format(3.14159))
          print(formatter.format("Hello, world!"))
          print(formatter.format([1, 2, 3, 4, 5]))
          print(formatter.format({"a": 1, "b": 2, "c": 3}))
          print(formatter.format(complex(1, 2)))  # Uses the default implementation

import unittest
          
          class Calculator:
              """A simple calculator class."""
              
              def add(self, a, b):
                  """Add two numbers."""
                  return a + b
              
              def subtract(self, a, b):
                  """Subtract b from a."""
                  return a - b
              
              def multiply(self, a, b):
                  """Multiply two numbers."""
                  return a * b
              
              def divide(self, a, b):
                  """Divide a by b."""
                  if b == 0:
                      raise ValueError("Cannot divide by zero")
                  return a / b
          
          class TestCalculator(unittest.TestCase):
              """Tests for the Calculator class."""
              
              def setUp(self):
                  """Set up for each test."""
                  self.calc = Calculator()
              
              def test_add(self):
                  """Test the add method."""
                  self.assertEqual(self.calc.add(2, 3), 5)
                  self.assertEqual(self.calc.add(-1, 1), 0)
                  self.assertEqual(self.calc.add(0, 0), 0)
              
              def test_subtract(self):
                  """Test the subtract method."""
                  self.assertEqual(self.calc.subtract(5, 3), 2)
                  self.assertEqual(self.calc.subtract(1, 1), 0)
                  self.assertEqual(self.calc.subtract(0, 5), -5)
              
              def test_multiply(self):
                  """Test the multiply method."""
                  self.assertEqual(self.calc.multiply(2, 3), 6)
                  self.assertEqual(self.calc.multiply(-2, 3), -6)
                  self.assertEqual(self.calc.multiply(0, 5), 0)
              
              def test_divide(self):
                  """Test the divide method."""
                  self.assertEqual(self.calc.divide(6, 3), 2)
                  self.assertEqual(self.calc.divide(5, 2), 2.5)
                  self.assertEqual(self.calc.divide(0, 5), 0)
                  
                  # Test division by zero raises ValueError
                  with self.assertRaises(ValueError):
                      self.calc.divide(5, 0)
          
          # Run the tests
          if __name__ == "__main__":
              unittest.main(argv=['first-arg-is-ignored'], exit=False)

import logging
          
          # Configure logging
          logging.basicConfig(level=logging.DEBUG, format='%(levelname)s - %(message)s')
          
          class ComplexCalculation:
              """A class with a complex calculation method to demonstrate debugging."""
              
              def __init__(self, base_value):
                  self.base_value = base_value
                  logging.info(f"Created ComplexCalculation with base_value={base_value}")
              
              def calculate(self, x, iterations=3):
                  """Perform a complex calculation."""
                  logging.debug(f"calculate called with x={x}, iterations={iterations}")
                  
                  result = self.base_value
                  
                  for i in range(iterations):
                      # Print statement for debugging
                      print(f"Iteration {i}: result = {result}")
                      
                      # Logging for more structured debugging
                      logging.debug(f"Iteration {i}: result before calculation = {result}")
                      
                      # Calculation step
                      prev_result = result
                      result = (result * x + i) / (i + 1)
                      
                      logging.debug(f"Iteration {i}: result after calculation = {result}")
                      
                      # Check for potential issues
                      if result == prev_result:
                          logging.warning(f"Result unchanged after iteration {i}")
                      
                      if not isinstance(result, (int, float)) or result > 1e6:
                          logging.error(f"Unexpected result value: {result}")
                          break
                  
                  logging.info(f"Final result: {result}")
                  return result
          
          # Using the class with debugging
          calc = ComplexCalculation(10)
          result = calc.calculate(2, iterations=4)
          print(f"Final result: {result}")