218. Dynamic Method Addition

---

🔹 1. Adding a Method to an Instance

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

def say_hello(self):
    return f"Hello, my name is {self.name}!"

p = Person("Alice")

# Bind method to instance
p.say_hello = say_hello.__get__(p)  

print(p.say_hello())  # ✅ Output: Hello, my name is Alice!

✅ Fix: Use __get__() to bind a function to an instance.

---

🔹 2. Adding a Method to a Class

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

def say_hello(self):
    return f"Hello, my name is {self.name}!"

# Attach method to class dynamically
Person.say_hello = say_hello  

p = Person("Bob")
print(p.say_hello())  # ✅ Output: Hello, my name is Bob!

✅ Fix: Directly assign a function to a class, making it available to all instances.

---

🔹 3. Using types.MethodType for Dynamic Binding

from types import MethodType

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

def say_hello(self):
    return f"Hello, my name is {self.name}!"

p = Person("Charlie")

# Attach method dynamically using MethodType
p.say_hello = MethodType(say_hello, p)

print(p.say_hello())  # ✅ Output: Hello, my name is Charlie!

✅ Fix: MethodType ensures the function behaves as a method, keeping self bound correctly.

---

🔹 4. Adding a staticmethod Dynamically

class Math:
    pass

@staticmethod
def add(a, b):
    return a + b

# Assign as a static method
Math.add = add

print(Math.add(5, 3))  # ✅ Output: 8

✅ Fix: Use staticmethod() or decorator to add static methods dynamically.

---

🔹 5. Adding a classmethod Dynamically

class Animal:
    species = "Unknown"

def get_species(cls):
    return f"Species: {cls.species}"

# Attach as a class method
Animal.get_species = classmethod(get_species)

print(Animal.get_species())  # ✅ Output: Species: Unknown

✅ Fix: Use classmethod() to dynamically attach a method that operates on the class itself.

---

🔹 6. Adding a Method Inside __init__

class Car:
    def __init__(self, brand):
        self.brand = brand
        self.get_brand = lambda: f"Brand: {self.brand}"

c = Car("Tesla")
print(c.get_brand())  # ✅ Output: Brand: Tesla

✅ Fix: Assign a lambda function inside __init__ to define a method dynamically.

---

🔹 7. Using __dict__ to Modify Methods

class Dog:
    def __init__(self, name):
        self.name = name

def bark(self):
    return f"{self.name} says Woof!"

# Modify instance __dict__ to add method
d = Dog("Buddy")
d.__dict__['bark'] = MethodType(bark, d)

print(d.bark())  # ✅ Output: Buddy says Woof!

✅ Fix: Modify the instance’s __dict__ to dynamically add behavior.

---

🔹 8. Adding a Method Dynamically Using Decorators

class Robot:
    pass

def add_method(cls):
    def greet(self):
        return "Hello, I am a Robot!"
    cls.greet = greet
    return cls

@add_method
class AI:
    pass

r = AI()
print(r.greet())  # ✅ Output: Hello, I am a Robot!

✅ Fix: Use decorators to add methods dynamically before object creation.

---

🔹 9. Injecting Methods via Metaclass

class Meta(type):
    def __new__(cls, name, bases, dct):
        def greet(self):
            return "Hello from a metaclass-injected method!"
        dct["greet"] = greet
        return super().__new__(cls, name, bases, dct)

class Human(metaclass=Meta):
    pass

h = Human()
print(h.greet())  # ✅ Output: Hello from a metaclass-injected method!

✅ Fix: Metaclasses allow defining methods for all instances dynamically.

---

🔹 10. Attaching Methods from a Module or Another Class

class Cat:
    pass

class WildAnimal:
    def roar(self):
        return "Roarrr!"

# Attach method from another class
Cat.roar = WildAnimal.roar

c = Cat()
print(c.roar())  # ✅ Output: Roarrr!

✅ Fix: Borrow methods from other classes dynamically.

---

🚀 Summary: Ways to Dynamically Add Methods in Python