Python3中getargspec的替代方案？如何动态创建带命名参数的函数？

Got it, let's break this down step by step—you want to use Python's inspect module to introspect function parameters, check if multiple functions share matching parameter names, and even dynamically generate functions based on those parameters. Here's how to pull this off smoothly:

1. Introspecting Function Parameters (The Right Way) #

First off, a quick heads-up: inspect.getargspec() is deprecated in Python 3.0+. We'll use inspect.getfullargspec() instead—it handles modern Python features like keyword-only arguments and variable-length args far better.

Here's how to grab parameter names for your example functions:

import inspect

def func1(a, b):
    return a + b

def func2(a):
    return a

def func3(b):
    return b

# Fetch parameter lists
args_func1 = inspect.getfullargspec(func1).args
args_func2 = inspect.getfullargspec(func2).args
args_func3 = inspect.getfullargspec(func3).args

print(args_func1)  # Output: ['a', 'b']
print(args_func2)  # Output: ['a']
print(args_func3)  # Output: ['b']

If you need to handle functions with *args or **kwargs, getfullargspec() also gives you access to those via the varargs and varkw attributes.

2. Checking if Multiple Functions Have Identical Parameters #

To compare parameter sets across functions, we can build a simple helper function that standardizes the parameter lists and checks for equality:

def functions_share_params(*funcs):
    # Get the parameter list for each function
    param_lists = [inspect.getfullargspec(func).args for func in funcs]
    # Verify all lists match the first one
    return all(params == param_lists[0] for params in param_lists)

# Test cases
print(functions_share_params(func1, func1))  # True
print(functions_share_params(func2, func3))  # False (['a'] vs ['b'])
print(functions_share_params(func2, func2))  # True

3. Dynamically Creating Functions #

Now for the fun part—generating functions on the fly based on parameter names. There are a couple of clean ways to do this:

Option 1: Using Closures (Flexible for Custom Logic) #

This method lets you pass custom logic as a callable, making it great for reusable dynamic functions:

def create_dynamic_func(param_names, logic):
    """
    Create a function with the given parameter names.
    `logic` is a callable that accepts params in the order of `param_names` and returns a value.
    """
    def dynamic_func(*args, **kwargs):
        # Map positional/keyword args to parameter names
        param_values = dict(zip(param_names, args))
        param_values.update(kwargs)
        # Pass values to the logic in the correct order
        return logic(*[param_values[name] for name in param_names])
    
    # Give the function a descriptive name for debugging
    dynamic_func.__name__ = f"dynamic_{'_'.join(param_names)}"
    return dynamic_func

# Example: Create a function that sums 3 parameters
sum_3 = create_dynamic_func(['x', 'y', 'z'], lambda a, b, c: a + b + c)
print(sum_3(1, 2, 3))  # Output: 6
print(sum_3(x=4, y=5, z=6))  # Output: 15

# Example: Create a function that returns the second parameter
get_second = create_dynamic_func(['a', 'b'], lambda a, b: b)
print(get_second(10, 20))  # Output: 20

Option 2: Using exec (For Simple String-Based Expressions) #

If you want to define the function's return logic as a string (good for straightforward expressions), exec works well:

def create_dynamic_func_exec(param_names, return_expr):
    """Generate a function using a string-based return expression."""
    sig = ", ".join(param_names)
    # Build the function code as a string
    func_code = f"""def dynamic_func({sig}):
    return {return_expr}"""
    
    # Execute the code and extract the function from the local scope
    local_scope = {}
    exec(func_code, globals(), local_scope)
    dynamic_func = local_scope['dynamic_func']
    dynamic_func.__name__ = f"dynamic_{'_'.join(param_names)}"
    
    return dynamic_func

# Example: Create a multiplication function
multiply = create_dynamic_func_exec(['a', 'b'], 'a * b')
print(multiply(3, 4))  # Output: 12

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