基于usr_input动态导入模块遇问题，寻求预导入替代方案

Got it, let's fix this by ditching the in-function dynamic imports and switching to a clean pre-import + lookup dictionary approach. This avoids the scoping, performance, or repeat-import issues you're hitting, while keeping the flexibility to map user input to your unified-interface classes.

Step 1: Project Structure & Unified Interface Setup #

First, let's assume you have these files (adjust names to match your actual setup):

• main.py: Your entry point with the main function
• my_utils.py: Contains your myfun function
• module_x.py, module_y.py, etc.: The modules with classes that share a unified interface (e.g., all have an execute() method)

For example, here's what a module with the unified interface looks like:
module_x.py

class ModuleX:
    def execute(self, *args, **kwargs):
        # Your logic here
        return f"Running ModuleX with input: {args}"

module_y.py

class ModuleY:
    def execute(self, *args, **kwargs):
        # Your logic here
        return f"Running ModuleY with input: {args}"

Step 2: Pre-Import & Mapping in my_utils.py #

Instead of importing inside myfun, pre-import all required modules upfront and create a dictionary that maps user input values directly to the corresponding classes. This makes lookups fast and avoids import-related headaches.

my_utils.py

# Pre-import all your modules once, at the top of the file
from module_x import ModuleX
from module_y import ModuleY

# Create a lookup map: user input string → corresponding class
INPUT_TO_MODULE = {
    "x": ModuleX,
    "y": ModuleY,
    # Add more entries here as you add new modules
}

def myfun(usr_input):
    # Fetch the class from our pre-defined mapping (normalize input to avoid case issues)
    TargetClass = INPUT_TO_MODULE.get(usr_input.lower())

    if not TargetClass:
        # Handle invalid input gracefully
        raise ValueError(f"Unrecognized input: '{usr_input}'. Valid options are: {', '.join(INPUT_TO_MODULE.keys())}")
    
    # Initialize the class and call the unified interface method
    instance = TargetClass()
    # If your method needs parameters, pass them here
    return instance.execute(usr_input)

Step 3: Call myfun from main.py #

Your main file stays clean, just pass the user input to myfun as before:

main.py

from my_utils import myfun

def main():
    usr_input = input("Enter module identifier (x/y): ").strip()
    try:
        result = myfun(usr_input)
        print(result)
    except ValueError as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    main()

Bonus: Scaling with Enums (Optional) #

If you have a lot of modules, using an enum can make your mapping more structured and easier to maintain:

my_utils.py (with Enum)

from enum import Enum
from module_x import ModuleX
from module_y import ModuleY

class ModuleMapping(Enum):
    MODULE_X = ("x", ModuleX)
    MODULE_Y = ("y", ModuleY)

    @classmethod
    def get_class(cls, input_str):
        for entry in cls:
            if entry.value[0] == input_str.lower():
                return entry.value[1]
        return None

def myfun(usr_input):
    TargetClass = ModuleMapping.get_class(usr_input)
    if not TargetClass:
        valid_options = ", ".join([entry.value[0] for entry in ModuleMapping])
        raise ValueError(f"Invalid input. Choose from: {valid_options}")
    
    instance = TargetClass()
    return instance.execute(usr_input)

Why This Works Better Than In-Function Imports #

• No repeated imports: Modules are loaded once when my_utils.py is imported, not every time myfun is called.
• Better IDE support: Pre-imported classes are visible to your IDE, so you get auto-completion and type checking.
• Cleaner scoping: Avoids any weird scoping issues that can come with importing inside a function.
• Easier debugging: Errors in module imports are caught when your app starts, not mid-execution.

内容的提问来源于stack exchange，提问作者user4340463