Dynamic instantiation from string name of a class in dynamically imported module?

Reduce, Reuse, Recycle: Packing Logic into a Function

To avoid the "copy, paste, regret" cycle, pack dynamic instantiation logic into a manageable function. This reusable piece saves you repeated work like a relentless ant 🐜.

def get_instance(module_name, class_name):
    try:
        module = import_module(module_name)
        classname = getattr(module, class_name)
        instance = classname()
        return instance
    except ImportError:
        print("The module doesn't exist, unlike unicorns 🦄")
        return None
    except AttributeError:
        print("That class doesn’t live here, maybe it's gone for a pint 🍺?")
        return None


Logging errors helps you troubleshoot problematic imports & instantiations, catching issues as a "fly" with the "swat" 💥🪰.

Drone Delivery: Handling Dynamic Submodule Imports

If your package includes several submodules, correct use of import_module becomes more essential than a hot cup of java in the morning ☕. Properly handle paths when accessing submodules.

submodule_path = 'package.submodule' # Replace with your submodule's path
instance = get_instance(submodule_path, class_name)

# Wonder how UPS does this all the time!? 📦


This approach simplifies fetching instances, no matter how nested your directories are.

pydoc.locate: A road map for Full Class Paths

Handling module imports and getattr function calls can feel like juggling chainsaws 🪓. Thankfully, pydoc.locate handles the juggling act provided you supply the full path representation in a string.

import pydoc

full_class_path = 'package.module.YourClass'
class_instance = pydoc.locate(full_class_path)()

# Be careful with full paths, they might be longer than your grandma's tales 🧓💬


It’s almost like watching a magician pull a rabbit from a hat 🎩🐇. And yes, it prefers class_name without any arguments.

Traps, Pitfalls, and Banana Peels: What to watch out for

While dynamically importing and instantiating classes can feel like walking a tightrope, here are some safety nets:

• Confirm the existence of the desired module and class to avoid a nasty meeting with ImportError or AttributeError.
• Remember that any loaded modules maintain their standard behavior. Be aware of any resource setup or subclass registration.
• Parse strings to extract module and class names to avoid AttributeError.
• Always remember the shady character lurking in the corner, None — make sure you have something before trying to instantiate it.

Survival Skills: Handling those curveballs

Dodge the worst complications of dynamic instantiation by sharpening your core skills:

The Constructor Constructor: A Factory Function

Construct classes with a variable number of arguments. It’s as easy as this handy factory function that casually takes *args and **kwargs:

def factory(module_name, class_name, *args, **kwargs):
    module = import_module(module_name)
    class_ = getattr(module, class_name)
    instance = class_(*args, **kwargs)

    return instance  # And voila, instant rabbit, just add top hat 🎩🐇


We don't need no stinking TypeError: Use inspect to inspect constructors

Say a firm "No" to TypeError when passing arguments to classes. Tame unruly classes using the mighty inspect package:

import inspect

def safe_factory(module_name, class_name, *args, **kwargs):
    module = import_module(module_name)
    class_ = getattr(module, class_name)
    sig = inspect.signature(class_)
    bounded = sig.bind(*args, **kwargs)
    bounded.apply_defaults()

    return class_(*bounded.args, **bounded.kwargs) # Here's your new pet python 🐍. No, not the snake.


March of the singletons: Managing module-level behavior

Any importlib.import_module call will behave just like an import statement, so rest easy knowing your singletons, resources, and patterns work as expected.