Dynamic Method Creation at Runtime

Learn how to create and bind methods dynamically at runtime in Python using types and functions for more flexible and dynamic programming patterns.

Dynamic Method Creation at Runtime in Python

Python is a dynamic language that allows developers to modify classes and objects at runtime. This includes the ability to create methods dynamically and bind them to classes or instances. This feature is especially useful for metaprogramming, creating plugins, or designing flexible APIs.

Why Create Methods Dynamically?

Dynamic method creation lets you modify behavior without modifying original source code. It’s helpful in frameworks where behaviors need to be injected at runtime or when creating objects with custom behavior based on runtime conditions.

Adding Methods to Instances

Let's start by adding a new method to an existing object at runtime. We’ll define a simple function and bind it to an instance:

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

p = Person(\\"John\\")

# Define a new method
def say_hello(self):
    return f\\"Hello, my name is self.name\\"

# Bind it to the instance
import types
p.greet = types.MethodType(say_hello, p)

print(p.greet())  # Output: Hello, my name is John

This approach only affects the single instance p. Other instances won’t have this method.

Adding Methods to Classes

To add a method to all instances of a class, bind the function to the class itself:

# Add method to Person class
Person.greet = say_hello

p2 = Person(\\"Bob\\")
print(p2.greet())  # Output: Hello, my name is Bob

Now all instances of Person, existing and future, have the greet method.

Creating Methods Dynamically

We can even define methods dynamically using closures or lambda expressions:

def create_method(suffix):
    def dynamic_method(self):
        return f\\"self.name says suffix\\"
    return dynamic_method

# Bind a dynamically created method
Person.say_goodbye = create_method(\\"goodbye!\\")
p3 = Person(\\"Alice\\")
print(p3.say_goodbye())  # Output: Alice says goodbye!

Conclusion

Dynamic method creation is a powerful feature of Python that gives you more flexibility and allows for highly dynamic and adaptive code. It’s especially useful in plugin systems, decorators, and frameworks where behavior needs to be customized at runtime.

Subscribe to Our YouTube for More

Download as PDF

https://blog.arashtad.com/updates/dynamic-method-creation-at-runtime/?feed_id=13427&_unique_id=689b7005a7147