Adding a method to an existing object instance in Python

Developing wizard-level Python skills

Dynamically adding methods to an object is as simple as casting a types.MethodType spell, but Python holds deeper enchantments to boost your coding prowess.

Class-wide versus instance-specific enchantments

You can transform the class definition to affect all instances. This is like saying, "let there be light!" and creating a sun that shines on all:

class MyClass:
    pass

def new_class_method(self):
    print("Hello, Sun!")

MyClass.new_method = new_class_method  # Sun created, sunshine for everyone!


However, types.MethodType provides a way to alter only a specific instance. This is like whispering a secret into somebody's ear - it's just for them.

Unleashing the big bosses: Descriptors and Metaclasses

The mighty descriptors and metaclasses are the dragon and phoenix of Python, the advanced allies for veteran developers. Descriptors are the underlying wizardry that make Properties, Methods, and the Python data model fly:

class Descriptor:
    def __init__(self, function):
        self.function = function
    def __get__(self, obj, objtype=None):
        # Our function gets imbued with the mystic arts and flies!
        return types.MethodType(self.function, obj)

def new_method(self):
    print("By the power of descriptor!")

# Unleash the draconic might of the descriptor!
MyClass.new_method = Descriptor(new_method)


While metaclasses govern the realm of class creation, allowing you to alter classes like a god alters the laws of nature:

# This is the phoenix spell. Our metaclass rises from the ashes!
class Meta(type):
    def __new__(cls, name, bases, dct):
        x = super().__new__(cls, name, bases, dct)
        x.new_method = types.MethodType(new_method, x)
        return x

class MyClass(metaclass=Meta):  # Our class, reborn!
    pass


The cleric's advice: Code maintenance and best practices

Python's flexibility allows dynamic code alterations, but use these powers wisely, young wizard! Always remember: with great power comes great code maintenance responsibility. Techniques like functools.partial can be your trusty wand for adding methods with pre-attached arguments:

from functools import partial

obj.new_method = partial(leviosa_spell, feather)
# Your spell, pre-attached with a feather. Time to make it fly!


Moreover, claw back from overusing enchantments that could blur code readability and future maintainability. Monkey patching, while a clever trick, often leaves bananas on the floor for others to trip over!

Patching instances: Proceed with caution 🚧

When patching instances, tread softly! It's like adding a secret ingredient to your grandma's famous cookie recipe. One excess chocolate chip can threaten the family tradition!

obj1.new_method = types.MethodType(new_method, obj1)
obj2.new_method = types.MethodType(new_method, obj2)
# Grandma's cookie recipe now makes chocolate chip & banana cookies!


Introduce changes only when needed and with full understanding of maintenance implications. Ensure that added methods are consistent and carefully used throughout the object's life. Stray bananas are anything but appetizing!