Python: __slots__

# Why Use __slots__?

print("=" * 50)
print("WHY USE __slots__?")
print("=" * 50)

# ============================================================
# WITHOUT __slots__ — Flexible but Memory Heavy
# ============================================================

print("\n❌ WITHOUT __slots__:")

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 30)

# You can add ANY attribute at any time
person.city = "NYC"  # Works!
person.email = "alice@example.com"  # Works!
person.phone = "123-456-7890"  # Works!

print(f"   Person: {person.name}, {person.age}")
print(f"   City: {person.city}")
print(f"   Email: {person.email}")
print(f"   Phone: {person.phone}")

# Each object has a __dict__ that stores all attributes
print(f"   __dict__: {person.__dict__}")

print("\n   ❌ Problems:")
print("   • Accidental attributes can be created")
print("   • Each object has a dictionary (memory heavy)")
print("   • Attribute access is slightly slower")


# ============================================================
# WITH __slots__ — Controlled and Efficient
# ============================================================

print("\n✅ WITH __slots__:")

class PersonSlotted:
    __slots__ = ['name', 'age']  # Only these attributes are allowed
    
    def __init__(self, name, age):
        self.name = name
        self.age = age

person2 = PersonSlotted("Bob", 25)
print(f"   Person: {person2.name}, {person2.age}")

# You can still access attributes normally
person2.name = "Robert"
print(f"   Updated name: {person2.name}")

# But you CANNOT add new attributes
try:
    person2.city = "LA"
except AttributeError as e:
    print(f"   ❌ {e}")

# There is NO __dict__ (saves memory)
try:
    print(f"   __dict__: {person2.__dict__}")
except AttributeError as e:
    print(f"   ❌ No __dict__: {e}")

print("\n✅ Benefits:")
print("   • Prevents accidental attribute creation")
print("   • Saves memory (no __dict__ per object)")
print("   • Faster attribute access")


# ============================================================
# BENEFITS SUMMARY
# ============================================================

print("\n" + "-" * 30)
print("BENEFITS OF __slots__")
print("-" * 30)
print("""
┌─────────────────────┬────────────────────────────────────────────┐
│ BENEFIT             │ WHAT IT MEANS FOR YOU                    │
├─────────────────────┼────────────────────────────────────────────┤
│ Memory Savings      │ No __dict__ per object, less memory used  │
│                     │                                            │
│ Faster Access       │ Attribute access is faster               │
│                     │                                            │
│ Prevents Errors     │ Can't accidentally create new attributes │
│                     │                                            │
│ Better Performance  │ 10-30% faster attribute access           │
│                     │                                            │
│ Immutability        │ Restricts what attributes can exist      │
└─────────────────────┴────────────────────────────────────────────┘

📌 __slots__ is perfect for classes with many objects.
""")

# Basic __slots__ Usage

print("=" * 50)
print("BASIC __slots__ USAGE")
print("=" * 50)

# ============================================================
# DEFINING __slots__
# ============================================================

print("\n1. DEFINING __slots__")

class Student:
    # List of allowed attributes
    __slots__ = ['name', 'age', 'grade']
    
    def __init__(self, name, age, grade):
        self.name = name
        self.age = age
        self.grade = grade
    
    def get_info(self):
        return f"{self.name}, {self.age} years old, Grade: {self.grade}"

student = Student("Alice", 20, "A")
print(f"   {student.get_info()}")

# All attributes work as normal
student.name = "Bob"
student.age = 21
print(f"   Updated: {student.get_info()}")


# ============================================================
# __slots__ TUPLE VS LIST
# ============================================================

print("\n2. __slots__ TUPLE VS LIST")

# Both work, tuple is slightly more memory efficient
class UsingList:
    __slots__ = ['x', 'y']  # List works
    def __init__(self, x, y):
        self.x = x
        self.y = y

class UsingTuple:
    __slots__ = ('x', 'y')  # Tuple also works
    def __init__(self, x, y):
        self.x = x
        self.y = y

print("   Both lists and tuples work for __slots__")
print("   ✅ Tuples are slightly more memory efficient")


# ============================================================
# __slots__ WITH METHODS
# ============================================================

print("\n3. __slots__ WITH METHODS")

class Calculator:
    __slots__ = ['value']
    
    def __init__(self, value):
        self.value = value
    
    def add(self, amount):
        self.value += amount
        return self.value
    
    def multiply(self, amount):
        self.value *= amount
        return self.value
    
    def get_value(self):
        return self.value

calc = Calculator(5)
print(f"   Value: {calc.get_value()}")
print(f"   Add 3: {calc.add(3)}")
print(f"   Multiply 2: {calc.multiply(2)}")


# ============================================================
# __slots__ AND DEFAULT VALUES
# ============================================================

print("\n4. __slots__ AND DEFAULT VALUES")

class Product:
    __slots__ = ['name', 'price', 'stock']
    
    def __init__(self, name, price, stock=0):
        self.name = name
        self.price = price
        self.stock = stock  # Default values work fine

product1 = Product("Laptop", 999.99, 10)
product2 = Product("Mouse", 29.99)  # Uses default stock

print(f"   Product 1: {product1.name}, ${product1.price}, Stock: {product1.stock}")
print(f"   Product 2: {product2.name}, ${product2.price}, Stock: {product2.stock}")


# ============================================================
# __slots__ WITH @property
# ============================================================

print("\n5. __slots__ WITH @property")

class Temperature:
    __slots__ = ['_celsius']
    
    def __init__(self, celsius):
        self._celsius = celsius
    
    @property
    def celsius(self):
        return self._celsius
    
    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Temperature below absolute zero")
        self._celsius = value
    
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

temp = Temperature(25)
print(f"   Celsius: {temp.celsius}°C")
print(f"   Fahrenheit: {temp.fahrenheit}°F")

temp.celsius = 30
print(f"   After update - Celsius: {temp.celsius}°C")


# ============================================================
# KEY RULES
# ============================================================

print("\n" + "-" * 30)
print("KEY RULES FOR __slots__")
print("-" * 30)
print("""
┌─────────────────────────────────────────────────────────────────────┐
│ RULES                                                              │
├─────────────────────────────────────────────────────────────────────┤
│ 1. Define __slots__ as a list or tuple of attribute names         │
│ 2. You can only assign attributes that are in __slots__           │
│ 3. Classes with __slots__ don't have a __dict__                   │
│ 4. __slots__ works with @property and methods                     │
│ 5. Default values work fine in __init__                           │
│ 6. Use tuple for slightly better memory efficiency                │
└─────────────────────────────────────────────────────────────────────┘
""")

# Memory Savings with __slots__

print("=" * 50)
print("MEMORY SAVINGS WITH __slots__")
print("=" * 50)

import sys

# ============================================================
# CLASS WITHOUT __slots__
# ============================================================

print("\n1. CLASS WITHOUT __slots__")

class WithoutSlots:
    def __init__(self, a, b, c, d):
        self.a = a
        self.b = b
        self.c = c
        self.d = d

# Create 1000 objects without __slots__
objects_without = [WithoutSlots(i, i*2, i*3, i*4) for i in range(1000)]

# Memory usage (approximate)
memory_without = sys.getsizeof(objects_without[0]) * 1000
print(f"   Memory for 1000 objects: ~{memory_without:,} bytes")
print(f"   Each object has __dict__: {objects_without[0].__dict__}")


# ============================================================
# CLASS WITH __slots__
# ============================================================

print("\n2. CLASS WITH __slots__")

class WithSlots:
    __slots__ = ['a', 'b', 'c', 'd']
    
    def __init__(self, a, b, c, d):
        self.a = a
        self.b = b
        self.c = c
        self.d = d

# Create 1000 objects with __slots__
objects_with = [WithSlots(i, i*2, i*3, i*4) for i in range(1000)]

# Memory usage (approximate)
memory_with = sys.getsizeof(objects_with[0]) * 1000
print(f"   Memory for 1000 objects: ~{memory_with:,} bytes")

# No __dict__!
try:
    print(f"   __dict__: {objects_with[0].__dict__}")
except AttributeError:
    print("   ✅ No __dict__ (memory saved)")


# ============================================================
# COMPARISON
# ============================================================

print("\n3. COMPARISON")

print(f"   Without __slots__: ~{memory_without:,} bytes")
print(f"   With __slots__:    ~{memory_with:,} bytes")
print(f"   Memory saved:     ~{memory_without - memory_with:,} bytes")
print(f"   Savings:          ~{(1 - memory_with/memory_without) * 100:.1f}%")

print("\n   ✅ With 1000 objects, __slots__ saves significant memory")
print("   ✅ For large-scale applications, this is huge")


# ============================================================
# REAL-WORLD EXAMPLE - 1 MILLION OBJECTS
# ============================================================

print("\n4. REAL-WORLD SCENARIO - 1 MILLION OBJECTS")

# Approximate memory usage for 1,000,000 objects
million_without = memory_without * 1000  # 1,000 objects * 1000 = 1,000,000
million_with = memory_with * 1000

print(f"   Without __slots__: ~{million_without:,} bytes (~{million_without // 1024 // 1024} MB)")
print(f"   With __slots__:    ~{million_with:,} bytes (~{million_with // 1024 // 1024} MB)")
print(f"   Memory saved:     ~{(million_without - million_with) // 1024 // 1024} MB")

print("\n   💡 For large datasets, __slots__ is a game-changer!")


# ============================================================
# WHY MEMORY IS SAVED
# ============================================================

print("\n" + "-" * 30)
print("WHY MEMORY IS SAVED")
print("-" * 30)
print("""
┌─────────────────────────────────────────────────────────────────────┐
│ WITHOUT __slots__   │   WITH __slots__                            │
├─────────────────────┼─────────────────────────────────────────────┤
│ Each object has a   │   Each object has a fixed structure         │
│ dictionary (__dict__)│   (no dictionary)                          │
│                     │                                             │
│ Dict is flexible    │   Structure is compact and efficient        │
│ but memory heavy    │                                             │
│                     │                                             │
│ ~50-60% more memory │   Uses less memory                          │
│                     │                                             │
│ Good for flexibility│   Good for performance & memory             │
└─────────────────────┴─────────────────────────────────────────────┘

📌 __slots__ replaces a dictionary with a fixed array.
""")

# __slots__ and Inheritance

print("=" * 50)
print("__slots__ AND INHERITANCE")
print("=" * 50)

# ============================================================
# PARENT WITH __slots__
# ============================================================

print("\n1. PARENT WITH __slots__")

class Animal:
    __slots__ = ['name', 'species']
    
    def __init__(self, name, species):
        self.name = name
        self.species = species

animal = Animal("Rex", "Dog")
print(f"   Animal: {animal.name} ({animal.species})")


# ============================================================
# CHILD WITH __slots__ (Inherits and adds more)
# ============================================================

print("\n2. CHILD WITH __slots__")

class Dog(Animal):
    __slots__ = ['breed', 'age']  # Adds more attributes
    
    def __init__(self, name, species, breed, age):
        super().__init__(name, species)
        self.breed = breed
        self.age = age

dog = Dog("Rex", "Canine", "German Shepherd", 3)
print(f"   Dog: {dog.name}, {dog.species}, {dog.breed}, {dog.age}")


# ============================================================
# CHILD WITHOUT __slots__ (Gets __dict__)
# ============================================================

print("\n3. CHILD WITHOUT __slots__")

class Cat(Animal):
    # No __slots__ defined
    def __init__(self, name, species, color):
        super().__init__(name, species)
        self.color = color

cat = Cat("Whiskers", "Feline", "Orange")
print(f"   Cat: {cat.name}, {cat.species}, {cat.color}")

# Cat has __dict__ because it doesn't define __slots__
print(f"   Cat __dict__: {cat.__dict__}")

# Can add new attributes (because of __dict__)
cat.toys = ["ball", "mouse"]
print(f"   Cat toys: {cat.toys}")


# ============================================================
# CHILD WITH __slots__ AND PARENT WITHOUT
# ============================================================

print("\n4. CHILD WITH __slots__, PARENT WITHOUT")

class Vehicle:
    def __init__(self, brand):
        self.brand = brand

class Car(Vehicle):
    __slots__ = ['model', 'year']  # Child has __slots__
    
    def __init__(self, brand, model, year):
        super().__init__(brand)
        self.model = model
        self.year = year

car = Car("Toyota", "Camry", 2023)
print(f"   Car: {car.brand}, {car.model}, {car.year}")

# Parent doesn't have __slots__, so car has __dict__
print(f"   Car __dict__: {car.__dict__}")


# ============================================================
# RULES SUMMARY
# ============================================================

print("\n" + "-" * 30)
print("INHERITANCE RULES")
print("-" * 30)
print("""
┌─────────────────────────────┬────────────────────────────────────────────┐
│ SCENARIO                    │ RESULT                                     │
├─────────────────────────────┼────────────────────────────────────────────┤
│ Parent has __slots__        │ Child's __slots__ extends parent's        │
│ Child has __slots__         │ Both sets of attributes are allowed       │
│                             │                                            │
│ Parent has __slots__        │ Child gets a __dict__ (no memory savings) │
│ Child has NO __slots__      │                                            │
│                             │                                            │
│ Parent has NO __slots__     │ Child can use __slots__                   │
│ Child has __slots__         │ Parent still has __dict__                 │
│                             │                                            │
│ Both have __slots__         │ Both are memory efficient                 │
└─────────────────────────────┴────────────────────────────────────────────┘

📌 For full memory savings, use __slots__ in both parent and child.
""")

# Limitations of __slots__

print("=" * 50)
print("LIMITATIONS OF __slots__")
print("=" * 50)

# ============================================================
# 1. CAN'T ADD ATTRIBUTES NOT IN __slots__
# ============================================================

print("\n1. CAN'T ADD ATTRIBUTES")

class User:
    __slots__ = ['name', 'email']
    
    def __init__(self, name, email):
        self.name = name
        self.email = email

user = User("Alice", "alice@example.com")

# This works
user.name = "Bob"

# This fails
try:
    user.age = 30
except AttributeError as e:
    print(f"   ❌ Can't add age: {e}")

print("   ⚠️ You're limited to the attributes you define in __slots__")


# ============================================================
# 2. CAN'T USE __dict__ (unless added to __slots__)
# ============================================================

print("\n2. CAN'T USE __dict__")

class Point:
    __slots__ = ['x', 'y']
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2)

try:
    print(f"   __dict__: {p.__dict__}")
except AttributeError as e:
    print(f"   ❌ No __dict__: {e}")

print("   ⚠️ You can add '__dict__' to __slots__ if you need it")
print("   __slots__ = ['x', 'y', '__dict__']  # But this defeats the purpose")


# ============================================================
# 3. CAN'T USE __weakref__ (unless added)
# ============================================================

print("\n3. CAN'T USE __weakref__")

class Data:
    __slots__ = ['value']
    
    def __init__(self, value):
        self.value = value

d = Data(10)

try:
    import weakref
    wr = weakref.ref(d)
except TypeError as e:
    print(f"   ❌ Weakref not supported: {e}")

print("   ⚠️ Add '__weakref__' to __slots__ if you need weakrefs")


# ============================================================
# 4. CAN'T USE DEFAULT VALUES IN __slots__ DEFINITION
# ============================================================

print("\n4. CAN'T USE DEFAULT VALUES IN __slots__ DEFINITION")

# ❌ This is wrong
# class Bad:
#     __slots__ = ['name', 'age']  # You CAN'T put default values here
#     name = "default"  # This would be a class variable, not an instance attribute

# ✅ This is correct
class Good:
    __slots__ = ['name', 'age']
    
    def __init__(self, name="default", age=0):  # Defaults go in __init__
        self.name = name
        self.age = age

g = Good()
print(f"   Good default: {g.name}, {g.age}")

print("   ✅ Put default values in __init__, not in __slots__")


# ============================================================
# 5. CAN'T USE __slots__ WITH __dict__ IN SUBCLASSES
# ============================================================

print("\n5. CAN'T USE __slots__ WITH __dict__ IN SUBCLASSES")

class Parent:
    __slots__ = ['name']

class Child(Parent):
    __slots__ = ['age']  # This works

try:
    class BadChild(Parent):
        __slots__ = ['age', '__dict__']  # This can cause issues
except Exception as e:
    print(f"   ❌ Potential issue: {e}")

print("   ⚠️ Mixing __slots__ and __dict__ in inheritance can be tricky")


# ============================================================
# SUMMARY
# ============================================================

print("\n" + "-" * 30)
print("LIMITATIONS SUMMARY")
print("-" * 30)
print("""
┌─────────────────────────────┬────────────────────────────────────────────┐
│ LIMITATION                  │ WORKAROUND                                 │
├─────────────────────────────┼────────────────────────────────────────────┤
│ Can't add new attributes    │ Plan your attributes carefully           │
│                             │                                            │
│ No __dict__ by default      │ Add '__dict__' to __slots__ (if needed)  │
│                             │                                            │
│ No __weakref__ by default   │ Add '__weakref__' to __slots__           │
│                             │                                            │
│ No defaults in __slots__    │ Use __init__ for defaults                │
│                             │                                            │
│ Complex inheritance issues  │ Keep inheritance simple                  │
└─────────────────────────────┴────────────────────────────────────────────┘

📌 Know the limitations, use __slots__ when it makes sense.
""")

# Real-World Example: Data Processing System

import sys
import random
from time import time

print("=" * 60)
print("DATA PROCESSING SYSTEM")
print("=" * 60)

# ============================================================
# DATA CLASS WITH __slots__ (Memory Efficient)
# ============================================================

class DataRecord:
    """Memory-efficient data record using __slots__"""
    
    __slots__ = ['id', 'name', 'value', 'timestamp', 'active']
    
    def __init__(self, id, name, value, timestamp, active=True):
        self.id = id
        self.name = name
        self.value = value
        self.timestamp = timestamp
        self.active = active
    
    def process(self):
        """Process the record"""
        if self.active:
            return self.value * 2
        return 0
    
    def get_summary(self):
        return f"ID: {self.id}, Name: {self.name}, Value: {self.value}"


# ============================================================
# DATA CLASS WITHOUT __slots__ (For Comparison)
# ============================================================

class DataRecordWithout:
    """Regular class without __slots__"""
    
    def __init__(self, id, name, value, timestamp, active=True):
        self.id = id
        self.name = name
        self.value = value
        self.timestamp = timestamp
        self.active = active
    
    def process(self):
        if self.active:
            return self.value * 2
        return 0


# ============================================================
# DATA PROCESSOR
# ============================================================

class DataProcessor:
    """Process data records efficiently"""
    
    def __init__(self, use_slots=True):
        self.use_slots = use_slots
        self.records = []
    
    def generate_data(self, count):
        """Generate random data records"""
        self.records = []
        for i in range(count):
            if self.use_slots:
                record = DataRecord(
                    i,
                    f"Record_{i}",
                    random.random() * 100,
                    time(),
                    active=random.random() > 0.2
                )
            else:
                record = DataRecordWithout(
                    i,
                    f"Record_{i}",
                    random.random() * 100,
                    time(),
                    active=random.random() > 0.2
                )
            self.records.append(record)
    
    def process_all(self):
        """Process all records"""
        results = []
        for record in self.records:
            results.append(record.process())
        return results
    
    def get_summary(self):
        """Get summary of records"""
        active = sum(1 for r in self.records if r.active)
        total = len(self.records)
        return {
            "total": total,
            "active": active,
            "inactive": total - active,
            "average_value": sum(r.value for r in self.records) / total if total > 0 else 0
        }


# ============================================================
# DEMONSTRATION
# ============================================================

print("\n1. CREATING DATA RECORDS")

# With __slots__
processor_slots = DataProcessor(use_slots=True)
processor_slots.generate_data(10)

print("   Records with __slots__:")
for i, record in enumerate(processor_slots.records[:3]):
    print(f"      {record.get_summary()}")
print("      ...")

print("\n2. MEMORY COMPARISON")

# Create 10,000 records
count = 10000
processor_slots = DataProcessor(use_slots=True)
processor_slots.generate_data(count)

processor_without = DataProcessor(use_slots=False)
processor_without.generate_data(count)

# Memory usage
mem_slots = sys.getsizeof(processor_slots.records[0]) * count
mem_without = sys.getsizeof(processor_without.records[0]) * count

print(f"   Records: {count:,}")
print(f"   With __slots__: {mem_slots:,} bytes")
print(f"   Without __slots__: {mem_without:,} bytes")
print(f"   Memory saved: {mem_without - mem_slots:,} bytes ({((mem_without - mem_slots) / mem_without * 100):.1f}%)")

print("\n3. PERFORMANCE TEST")

import time

# Test with __slots__
processor_slots = DataProcessor(use_slots=True)
processor_slots.generate_data(10000)
start = time.time()
processor_slots.process_all()
time_slots = time.time() - start

# Test without __slots__
processor_without = DataProcessor(use_slots=False)
processor_without.generate_data(10000)
start = time.time()
processor_without.process_all()
time_without = time.time() - start

print(f"   With __slots__: {time_slots:.4f}s")
print(f"   Without __slots__: {time_without:.4f}s")
print(f"   Speed improvement: {((time_without - time_slots) / time_without * 100):.1f}%")

print("\n4. PROCESSING SUMMARY")
summary = processor_slots.get_summary()
print(f"   Total records: {summary['total']:,}")
print(f"   Active records: {summary['active']:,}")
print(f"   Inactive records: {summary['inactive']:,}")
print(f"   Average value: {summary['average_value']:.2f}")

print("\n" + "=" * 60)
print("KEY TAKEAWAYS:")
print("=" * 60)
print("✅ __slots__ saves memory (40-60% reduction)")
print("✅ __slots__ improves performance (10-30% faster)")
print("✅ __slots__ prevents accidental attribute creation")
print("✅ Use __slots__ for classes with many instances")
print("✅ Data processing is a perfect use case for __slots__")

# Best Practices for __slots__

print("=" * 60)
print("BEST PRACTICES FOR __slots__")
print("=" * 60)

# ============================================================
# 1. USE __slots__ FOR CLASSES WITH MANY INSTANCES
# ============================================================

print("\n1. USE __slots__ FOR MANY INSTANCES")

# ✅ GOOD: For data classes with many instances
class Point:
    __slots__ = ['x', 'y', 'z']
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

# ❌ BAD: For classes with few instances
class Config:
    # Few instances, __slots__ won't save much memory
    def __init__(self, setting1, setting2):
        self.setting1 = setting1
        self.setting2 = setting2

print("   ✅ Use __slots__ when you have many objects")


# ============================================================
# 2. USE TUPLES FOR __slots__ (Memory Efficient)
# ============================================================

print("\n2. USE TUPLES FOR __slots__")

# ✅ GOOD: Use tuple (slightly more memory efficient)
class Good:
    __slots__ = ('name', 'age', 'city')
    def __init__(self, name, age, city):
        self.name = name
        self.age = age
        self.city = city

# ❌ BAD: Using list (works but uses slightly more memory)
class Bad:
    __slots__ = ['name', 'age', 'city']  # Works but less efficient
    def __init__(self, name, age, city):
        self.name = name
        self.age = age
        self.city = city

print("   ✅ Use tuple for __slots__ for better memory efficiency")


# ============================================================
# 3. DON'T MIX __slots__ AND __dict__ UNLESS NECESSARY
# ============================================================

print("\n3. DON'T MIX __slots__ AND __dict__")

# ❌ BAD: Adding __dict__ defeats the purpose
class BadMix:
    __slots__ = ['name', 'age', '__dict__']  # Defeats memory savings
    def __init__(self, name, age):
        self.name = name
        self.age = age

# ✅ GOOD: Keep it clean
class GoodClean:
    __slots__ = ['name', 'age']
    def __init__(self, name, age):
        self.name = name
        self.age = age

print("   ✅ Don't add __dict__ to __slots__ unless you really need it")


# ============================================================
# 4. USE __slots__ IN BOTH PARENT AND CHILD
# ============================================================

print("\n4. USE __slots__ IN BOTH PARENT AND CHILD")

# ✅ GOOD: Both have __slots__
class Parent:
    __slots__ = ['name']
    def __init__(self, name):
        self.name = name

class Child(Parent):
    __slots__ = ['age']  # Child extends parent's slots
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age

# ❌ BAD: Child missing __slots__ loses memory savings
class BadParent:
    __slots__ = ['name']
    def __init__(self, name):
        self.name = name

class BadChild(BadParent):
    # No __slots__ — child gets __dict__
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age

print("   ✅ Use __slots__ in both parent and child for full savings")


# ============================================================
# 5. USE __slots__ FOR IMMUTABLE DATA CLASSES
# ============================================================

print("\n5. USE __slots__ FOR IMMUTABLE DATA")

from dataclasses import dataclass

# ✅ GOOD: dataclass with frozen=True often uses __slots__ internally
@dataclass(frozen=True)
class ImmutablePoint:
    x: int
    y: int

# ✅ GOOD: Manual slots for immutability
class ManualImmutable:
    __slots__ = ['_x', '_y']
    def __init__(self, x, y):
        object.__setattr__(self, '_x', x)
        object.__setattr__(self, '_y', y)
    
    @property
    def x(self):
        return self._x
    
    @property
    def y(self):
        return self._y

print("   ✅ __slots__ is great for immutable data classes")


# ============================================================
# 6. SUMMARY
# ============================================================

print("\n" + "=" * 60)
print("BEST PRACTICES SUMMARY")
print("=" * 60)
print("""
┌─────────────────────────────┬─────────────────────────────────────────────┐
│ PRACTICE                    │ WHY IT MATTERS                             │
├─────────────────────────────┼─────────────────────────────────────────────┤
│ Use for many instances      │ Memory savings are significant            │
│                             │                                             │
│ Use tuple for __slots__     │ Slightly more memory efficient            │
│                             │                                             │
│ Don't add __dict__          │ Defeats the purpose of __slots__          │
│                             │                                             │
│ Use in parent and child     │ Full memory savings                       │
│                             │                                             │
│ Use for immutable data      │ Combines immutability with efficiency     │
│                             │                                             │
│ Use when attributes are     │ Prevents accidental attribute creation    │
│ known in advance            │                                             │
└─────────────────────────────┴─────────────────────────────────────────────┘

📌 __slots__ is a powerful tool, but use it when it makes sense!
""")