Python: Constructors

# The __init__ method in action

class Book:
    def __init__(self, title, author, pages):
        """Initialize a new Book object"""
        print(f"Creating book: {title}")
        self.title = title
        self.author = author
        self.pages = pages
        self.is_open = False
    
    def open(self):
        self.is_open = True
        return f"Opening '{self.title}'"
    
    def close(self):
        self.is_open = False
        return f"Closing '{self.title}'"
    
    def get_info(self):
        status = "open" if self.is_open else "closed"
        return f"'{self.title}' by {self.author} - {self.pages} pages ({status})"

# The __init__ method is called when we create objects
book1 = Book("Python Guide", "John Smith", 350)
# Output: Creating book: Python Guide

book2 = Book("Data Science", "Jane Doe", 420)
# Output: Creating book: Data Science

# Each object is properly initialized
print(book1.get_info())  # 'Python Guide' by John Smith - 350 pages (closed)
print(book2.get_info())  # 'Data Science' by Jane Doe - 420 pages (closed)

# The __init__ method has set up each object correctly
book1.open()
print(book1.get_info())  # 'Python Guide' by John Smith - 350 pages (open)
                                

# Default constructor (no __init__ defined)

class EmptyClass:
    """A class without an __init__ method"""
    pass

# Python provides a default constructor
obj1 = EmptyClass()
obj2 = EmptyClass()

# The objects are created, but they have no attributes
print(obj1)  # <__main__.EmptyClass object at 0x...>
print(obj2)  # <__main__.EmptyClass object at 0x...>

# You can add attributes manually
obj1.name = "Object 1"
obj2.name = "Object 2"

print(obj1.name)  # Object 1
print(obj2.name)  # Object 2

# This works, but it's not ideal for most cases.
# It's better to define an __init__ method to set up attributes.

# Example with a class that only needs a default constructor
class Person:
    """A simple class using default constructor"""
    pass

# Create person objects
person1 = Person()
person2 = Person()

# Add attributes manually
person1.name = "Alice"
person1.age = 25
person2.name = "Bob"
person2.age = 30

print(f"{person1.name} is {person1.age} years old")
print(f"{person2.name} is {person2.age} years old")
                                

# Parameterized constructors

class Employee:
    """An employee with a parameterized constructor"""
    
    def __init__(self, name, position, salary):
        """Initialize employee with provided values"""
        self.name = name
        self.position = position
        self.salary = salary
        self.years_at_company = 0
        
        # We can also perform validation
        if salary < 0:
            self.salary = 0
            print("Warning: Salary cannot be negative")
    
    def get_info(self):
        return f"{self.name} - {self.position}, Salary: ${self.salary}"

# Creating objects with different values
alice = Employee("Alice", "Developer", 75000)
bob = Employee("Bob", "Designer", 65000)
charlie = Employee("Charlie", "Manager", 85000)

# Each object has its own data
print(alice.get_info())  # Alice - Developer, Salary: $75000
print(bob.get_info())    # Bob - Designer, Salary: $65000
print(charlie.get_info()) # Charlie - Manager, Salary: $85000

# Example with default values
class Product:
    def __init__(self, name, price, category="General", in_stock=True):
        self.name = name
        self.price = price
        self.category = category
        self.in_stock = in_stock
    
    def get_info(self):
        status = "In Stock" if self.in_stock else "Out of Stock"
        return f"{self.name} (${self.price}) - {self.category} - {status}"

# Using default values
laptop = Product("Laptop", 999.99, "Electronics")
phone = Product("Phone", 599.99, category="Electronics", in_stock=False)
book = Product("Book", 19.99)

print(laptop.get_info())  # Laptop ($999.99) - Electronics - In Stock
print(phone.get_info())   # Phone ($599.99) - Electronics - Out of Stock
print(book.get_info())    # Book ($19.99) - General - In Stock
                                

# Multiple ways to initialize objects

# Method 1: Using default parameters
class Rectangle:
    def __init__(self, width=0, height=0):
        self.width = width
        self.height = height
        self.area = width * height
    
    def get_info(self):
        return f"Rectangle: {self.width}x{self.height}, Area: {self.area}"

# Different ways to create rectangles
rect1 = Rectangle()               # Default: 0x0
rect2 = Rectangle(5)              # 5x0
rect3 = Rectangle(5, 3)           # 5x3

print(rect1.get_info())  # Rectangle: 0x0, Area: 0
print(rect2.get_info())  # Rectangle: 5x0, Area: 0
print(rect3.get_info())  # Rectangle: 5x3, Area: 15

# Method 2: Using class methods as alternative constructors
class Person:
    def __init__(self, name, age, city):
        self.name = name
        self.age = age
        self.city = city
    
    def get_info(self):
        return f"{self.name} ({self.age}) from {self.city}"
    
    # Alternative constructor from a dictionary
    @classmethod
    def from_dict(cls, data):
        return cls(data.get('name', 'Unknown'), 
                  data.get('age', 0), 
                  data.get('city', 'Unknown'))
    
    # Alternative constructor from a string
    @classmethod
    def from_string(cls, data_string):
        parts = data_string.split(',')
        name = parts[0].strip()
        age = int(parts[1].strip())
        city = parts[2].strip()
        return cls(name, age, city)

# Using different constructors
person1 = Person("Alice", 25, "NYC")
person2 = Person.from_dict({"name": "Bob", "age": 30, "city": "LA"})
person3 = Person.from_string("Charlie, 35, Chicago")

print(person1.get_info())  # Alice (25) from NYC
print(person2.get_info())  # Bob (30) from LA
print(person3.get_info())  # Charlie (35) from Chicago

# Method 3: Using *args and **kwargs
class FlexiblePerson:
    def __init__(self, *args, **kwargs):
        if len(args) == 3:
            # Positional arguments: name, age, city
            self.name, self.age, self.city = args
        elif len(args) == 2:
            # Positional arguments: name, age
            self.name, self.age = args
            self.city = "Unknown"
        else:
            # Keyword arguments
            self.name = kwargs.get('name', 'Unknown')
            self.age = kwargs.get('age', 0)
            self.city = kwargs.get('city', 'Unknown')
    
    def get_info(self):
        return f"{self.name} ({self.age}) from {self.city}"

# Different ways to create
fp1 = FlexiblePerson("Alice", 25, "NYC")
fp2 = FlexiblePerson("Bob", 30)
fp3 = FlexiblePerson(name="Charlie", city="Chicago")

print(fp1.get_info())  # Alice (25) from NYC
print(fp2.get_info())  # Bob (30) from Unknown
print(fp3.get_info())  # Charlie (0) from Chicago
                                

# __new__ vs __init__

class Person:
    def __new__(cls, name, age):
        """__new__ creates the object"""
        print(f"__new__ called: Creating a Person object for {name}")
        # Create the object
        instance = super().__new__(cls)
        return instance
    
    def __init__(self, name, age):
        """__init__ initializes the object"""
        print(f"__init__ called: Initializing {name}")
        self.name = name
        self.age = age
    
    def get_info(self):
        return f"{self.name} is {self.age} years old"

# Creating a Person object
print("Creating a Person...")
person = Person("Alice", 25)
print(person.get_info())

# Output:
# Creating a Person...
# __new__ called: Creating a Person object for Alice
# __init__ called: Initializing Alice
# Alice is 25 years old

# When to use __new__:
# - When you need to control object creation (singleton pattern)
# - When you're subclassing immutable types (like tuple or int)
# - When you need to return an existing object instead of a new one

# Example: Singleton pattern with __new__
class Singleton:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            print("Creating the singleton instance")
            cls._instance = super().__new__(cls)
        else:
            print("Returning existing singleton instance")
        return cls._instance
    
    def __init__(self):
        print("Initializing singleton")
        self.value = 0

# Testing the singleton
s1 = Singleton()  # Creating the singleton instance / Initializing singleton
s2 = Singleton()  # Returning existing singleton instance / Initializing singleton
s3 = Singleton()  # Returning existing singleton instance / Initializing singleton

print(s1 is s2)  # True
print(s2 is s3)  # True
                                

# Best practices for writing constructors

# 1. Keep it simple
# ✅ Good: Simple constructor with clear purpose
class User:
    def __init__(self, username, email):
        self.username = username
        self.email = email
        self.is_active = True

# ❌ Bad: Constructor doing too much
class UserBad:
    def __init__(self, username, email, data=None):
        self.username = username
        self.email = email
        self.is_active = True
        # Too much logic in constructor
        if data:
            self.process_data(data)
            self.validate_data()
            self.save_to_database()
            self.send_welcome_email()

# 2. Validate input when needed
class Product:
    def __init__(self, name, price):
        self.name = name.strip() if name else "Unknown"
        
        # Validate price
        if price < 0:
            raise ValueError("Price cannot be negative")
        self.price = price

# 3. Use default values wisely
class Book:
    def __init__(self, title, author, pages=0, isbn=None):
        self.title = title
        self.author = author
        self.pages = pages
        self.isbn = isbn if isbn else "Unknown"

# 4. Document your constructor
class Customer:
    """
    A class representing a customer.
    
    Attributes:
        name (str): Customer's full name
        email (str): Customer's email address
        tier (str): Membership tier (gold, silver, bronze)
    """
    def __init__(self, name, email, tier="bronze"):
        """
        Initialize a new customer.
        
        Args:
            name (str): Customer's full name
            email (str): Customer's email address
            tier (str): Membership tier (default: bronze)
        """
        self.name = name
        self.email = email
        self.tier = tier.lower()

# 5. Use type hints for clarity
class Employee:
    def __init__(self, name: str, position: str, salary: float) -> None:
        self.name = name
        self.position = position
        self.salary = salary

# 6. Keep constructor focused on initialization
class Order:
    def __init__(self, customer, items):
        self.customer = customer
        self.items = items
        self.total = sum(item.price for item in items)
        self.status = "pending"
    
    # Complex logic goes in other methods
    def process(self):
        self.status = "processing"
        # Processing logic...
    
    def complete(self):
        self.status = "completed"
        # Completion logic...