Of course! Loading code dynamically in Python is a powerful technique that allows you to load modules, classes, and functions at runtime, rather than at import time. This is essential for creating flexible, plugin-based architectures, reducing startup time, and executing code from sources like strings or network paths.

Let's break down the main ways to achieve this, from the most common to more advanced techniques.

The Standard Way: importlib

The modern, standard, and recommended way to load modules dynamically is with the importlib library. It's the foundation upon which Python's own import statement is built.

Scenario: Loading a module from a file path

Imagine you have a directory structure like this:

/my_project
|-- main.py
|-- plugins/
|   |-- __init__.py
|   |-- plugin_a.py
|   `-- plugin_b.py

plugins/plugin_a.py

# plugin_a.py
class PluginA:
    def run(self):
        print("Hello from Plugin A!")
    def get_name(self):
        return "Plugin A"

main.py Now, let's dynamically load plugin_a.py without having a static import plugins.plugin_a.

import importlib.util
import os
# Define the path to the plugin file
plugin_path = os.path.join(os.path.dirname(__file__), 'plugins', 'plugin_a.py')
# --- Step 1: Create a module spec ---
# A spec is a detailed description of how to load a module.
spec = importlib.util.spec_from_file_location("plugin_a_module", plugin_path)
# --- Step 2: Create a new module object from the spec ---
# This is like creating an empty box for the module's code.
plugin_module = importlib.util.module_from_spec(spec)
# --- Step 3: Execute the module in its new namespace ---
# This runs the code in plugin_a.py and populates the module object.
spec.loader.exec_module(plugin_module)
# --- Step 4: Use the loaded module ---
# You can now access anything defined in the file.
print(f"Successfully loaded module: {plugin_module}")
# Access the class from the dynamically loaded module
plugin_instance = plugin_module.PluginA()
plugin_instance.run()
print(f"Loaded plugin name: {plugin_instance.get_name()}")

Output:

Successfully loaded module: <module 'plugin_a_module' from '/path/to/my_project/plugins/plugin_a.py'>
Hello from Plugin A!
Loaded plugin name: Plugin A

A More Reusable Function

You can wrap this logic in a helper function to make it cleaner:

import importlib.util
import os
def load_module_from_path(module_name, file_path):
    """Dynamically loads a Python module from a file path."""
    if not os.path.exists(file_path):
        raise ImportError(f"File not found: {file_path}")
    spec = importlib.util.spec_from_file_location(module_name, file_path)
    if spec is None:
        raise ImportError(f"Could not create module spec for {file_path}")
    module = importlib.util.module_from_spec(spec)
    # To make the module accessible in sys.modules, you might want to do this:
    # sys.modules[module_name] = module
    spec.loader.exec_module(module)
    return module
# --- Usage ---
plugin_path = os.path.join(os.path.dirname(__file__), 'plugins', 'plugin_b.py')
# Let's assume plugin_b.py has a class PluginB
try:
    plugin_b_module = load_module_from_path("plugin_b_module", plugin_path)
    plugin_instance = plugin_b_module.PluginB()
    plugin_instance.run()
except ImportError as e:
    print(e)

The Classic Way: imp (Deprecated)

Before importlib was introduced, the imp module was used. You should avoid using it in new code as it is deprecated since Python 3.4 and will be removed in a future version. However, you might encounter it in older projects.

# DO NOT USE THIS IN NEW CODE
import imp
import os
plugin_path = os.path.join(os.path.dirname(__file__), 'plugins', 'plugin_a.py')
# imp.load_source creates and executes the module in one step
plugin_module = imp.load_source("plugin_a_module", plugin_path)
plugin_instance = plugin_module.PluginA()
plugin_instance.run()

Loading Code from a String or Bytes Object

Sometimes you don't have a file, but you have the source code as a string. You can use the exec() function for this.

main.py

plugin_code_string = """
class DynamicPlugin:
    def __init__(self, name):
        self.name = name
    def greet(self):
        print(f"Greetings from the dynamic plugin: {self.name}!")
"""
# Create a new, empty namespace (dictionary) for the code to execute in
# This isolates the dynamic code from your main program's global scope.
plugin_namespace = {}
# Execute the code in the provided namespace
exec(plugin_code_string, plugin_namespace)
# Now, the class 'DynamicPlugin' exists inside the namespace
print(f"Classes found in namespace: {[name for name in plugin_namespace if name[0].isupper()]}")
# You can instantiate the class from the namespace
dynamic_plugin = plugin_namespace['DynamicPlugin']("My Awesome Plugin")
dynamic_plugin.greet()

Output:

Classes found in namespace: ['DynamicPlugin']
Greetings from the dynamic plugin: My Awesome Plugin!

Warning: Using exec() with untrusted input is a major security risk, as it can execute arbitrary code. Only use it with code you trust or have generated yourself.

Loading Code from a Network URL (HTTP/HTTPS)

This is a more advanced use case. You can load a Python module directly from a web server. The importlib approach works here too, but you need to handle downloading the file first.

import importlib.util
import urllib.request
import tempfile
def load_module_from_url(url):
    """Loads a Python module from a URL."""
    try:
        # Download the file content
        with urllib.request.urlopen(url) as response:
            # Read the content as bytes
            code_bytes = response.read()
    except urllib.error.URLError as e:
        print(f"Error downloading module: {e}")
        return None
    # Create a temporary file to store the code
    # This is necessary because importlib needs a file path.
    with tempfile.NamedTemporaryFile(suffix='.py', delete=False) as temp_file:
        temp_file.write(code_bytes)
        temp_file_path = temp_file.name
    try:
        # Use the same importlib logic as before
        spec = importlib.util.spec_from_file_location("remote_module", temp_file_path)
        remote_module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(remote_module)
        return remote_module
    finally:
        # Clean up the temporary file
        os.unlink(temp_file_path)
# --- Usage ---
# (You would need a web server serving a .py file for this to work)
# Example URL (replace with a real one)
# url = "http://example.com/my_plugin.py"
# remote_plugin = load_module_from_url(url)
# if remote_plugin:
#     remote_plugin.run()

Advanced: Loading and Subclassing at Runtime

A very powerful pattern is to discover classes within a dynamically loaded module and use them.

Let's modify our plugin_a.py:

# plugins/plugin_a.py
class BasePlugin:
    def run(self):
        raise NotImplementedError
class PluginA(BasePlugin):
    def run(self):
        print("Plugin A is running!")
    def get_name(self):
        return "Plugin A"

Now, in main.py, we can load the module and find all classes that inherit from BasePlugin.

import importlib.util
import os
import inspect
# (Assuming the load_module_from_path function from earlier is defined here)
def load_module_from_path(module_name, file_path):
    spec = importlib.util.spec_from_file_location(module_name, file_path)
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module
# --- Main Logic ---
plugin_path = os.path.join(os.path.dirname(__file__), 'plugins', 'plugin_a.py')
plugin_module = load_module_from_path("plugin_a_module", plugin_path)
# Find all classes in the module that are subclasses of BasePlugin
for name, cls in inspect.getmembers(plugin_module, inspect.isclass):
    if issubclass(cls, plugin_module.BasePlugin) and cls is not plugin_module.BasePlugin:
        print(f"Found plugin class: {name}")
        # Instantiate and run it
        plugin_instance = cls()
        plugin_instance.run()

Output:

Found plugin class: PluginA
Plugin A is running!

This is the core principle behind many plugin systems, like those used in pytest or various web frameworks.

Summary: Which Method to Use?