从字典映射中动态调用函数失败，寻求技术解决方法

Looks like you're trying to map string function names to actual function calls based on your available array of dictionaries—great approach for flexible analysis workflows! The key issue here is that your func values are strings (like "draw_pareto"), but Python needs a reference to the actual function object to execute it. Here's how to fix this cleanly:

Recommended Approach: Use a Function Registry #

The safest and most maintainable way is to create a function registry—a dictionary that maps your string function names to the corresponding function objects. This avoids unsafe practices like eval() and makes it easy to manage which functions are available for dynamic calls.

Step 1: Define Your Function Registry #

First, create a registry that links the string names in your available array to the actual functions. Assuming you have draw_pareto defined somewhere in your code:

# Example placeholder for your draw_pareto function
def draw_pareto(analysis_name, col_name, required_cols, agg, analysis_type):
    # Replace with your actual function logic
    print(f"Executing {analysis_name}: {agg} of {col_name} (requires {required_cols})")

# Create the function registry
function_registry = {
    "draw_pareto": draw_pareto
    # Add other function mappings here if you expand later
}

Step 2: Iterate and Call Functions Dynamically #

Now loop through your available array, look up each function in the registry, and call it with the parameters from the dictionary:

# Your existing available array setup
available = []
available.append({ 
    'analysis_name': 'Category X Total Payment', 
    'col_name': 'VALUE', 
    'required_cols': ['Category','VALUE'], 
    'agg':'SUM', 
    'analysis_type': 'pareto-bar', 
    'func': 'draw_pareto'
})
available.append({ 
    'analysis_name': 'Category X Count', 
    'col_name': 'Count', 
    'required_cols': ['Category','VALUE'], 
    'agg':'Count', 
    'analysis_type': 'pareto-bar', 
    'func': 'draw_pareto'
})

# Process each analysis entry
for analysis in available:
    func_name = analysis['func']
    
    # Look up the function in the registry
    target_func = function_registry.get(func_name)
    
    if not target_func:
        print(f"Warning: Function '{func_name}' not found in registry. Skipping {analysis['analysis_name']}")
        continue
    
    # Pass relevant parameters to the function using keyword arguments
    target_func(
        analysis_name=analysis['analysis_name'],
        col_name=analysis['col_name'],
        required_cols=analysis['required_cols'],
        agg=analysis['agg'],
        analysis_type=analysis['analysis_type']
    )

Why This Works #

• Safety: Unlike using globals()[func_name] or eval(func_name), the registry only includes functions you explicitly allow, preventing accidental execution of unintended code.
• Maintainability: Adding new functions later just requires updating the registry and adding the new function definition—no messy string parsing needed.
• Readability: The keyword arguments make it clear exactly what data is being passed to each function.

Alternative (Not Recommended): Using globals() #

If you're working in a controlled environment and trust all the function names in your available array, you could use the global namespace to look up functions directly. However, this is risky if your func values ever come from user input or untrusted sources:

for analysis in available:
    func_name = analysis['func']
    try:
        target_func = globals()[func_name]
        # Pass all dictionary entries as keyword arguments (adjust if your function expects fewer params)
        target_func(**analysis)
    except KeyError:
        print(f"Function {func_name} does not exist in the global namespace")

Stick with the registry approach for production code—it's the industry standard for dynamic function calling in Python.

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