如何快速将函数列表应用于对应参数列表？

Great question! I’ve dealt with this exact scenario when optimizing batch processing of custom mathematical functions, so here are the approaches that worked best for me—focused on cutting down Python loop overhead or leveraging parallelism for faster execution:

1. Numba JIT Compiled Loop (Best for Low-Overhead Speed) #

Python’s loop overhead is often the culprit when list comprehensions feel slow. Numba compiles your loop to machine code, eliminating that overhead entirely. This works especially well if your functions are compatible with Numba (most numpy operations and pure Python functions are, as long as they don’t use unsupported features like dynamic typing inside the loop).

Here’s how to implement it:

import numba
import numpy as np

# Example functions and parameters
def f1(x): return np.sin(x)
def f2(x): return np.cos(x)
def f3(x): return np.exp(x)
def f4(x): return np.log(x)

f = [f1, f2, f3, f4]
a = [1.0, 2.0, 3.0, 4.0]

# Convert to numpy arrays (Numba handles these efficiently)
funcs = np.array(f, dtype=object)
args = np.array(a)

@numba.jit(nopython=True)  # Critical for maximum speed
def apply_funcs(funcs, args):
    result = np.empty_like(args)
    for i in range(len(funcs)):
        result[i] = funcs[i](args[i])
    return result

# Compute results
output = apply_funcs(funcs, args)
print(output)  # Output: [0.84147098 0.41614684 20.08553692 1.38629436]

For large lists (think thousands of function-parameter pairs), this will be significantly faster than a list comprehension.

2. Parallel Execution (Best for CPU-Bound Functions) #

If each function call is computationally expensive (e.g., heavy simulations, complex math), parallelizing the execution can speed things up by utilizing multiple CPU cores. Use concurrent.futures for a clean implementation:

from concurrent.futures import ProcessPoolExecutor

# Example: Slow functions (simulated with sleep)
import time
def f1(x): 
    time.sleep(0.1)
    return np.sin(x)
def f2(x): 
    time.sleep(0.1)
    return np.cos(x)
def f3(x): 
    time.sleep(0.1)
    return np.exp(x)
def f4(x): 
    time.sleep(0.1)
    return np.log(x)

f = [f1, f2, f3, f4]
a = [1.0, 2.0, 3.0, 4.0]

# Use ProcessPoolExecutor for CPU-bound tasks (avoids GIL limitations)
with ProcessPoolExecutor() as executor:
    # Zip function-parameter pairs and map to executor
    output = list(executor.map(lambda pair: pair[0](pair[1]), zip(f, a)))

print(output)

Note: Use ThreadPoolExecutor instead if your functions are I/O-bound (e.g., making API calls). Parallelism has overhead, so it’s only worth it if individual function calls take longer than ~1ms.

3. Numpy Vectorize (Syntactic Sugar, Not a Speedup) #

If you want a more "numpy-like" syntax but don’t need a speed boost, numpy.vectorize is an option—but it’s not faster than a list comprehension (it’s just a wrapper around a Python loop). Use it only for readability:

import numpy as np

vec_apply = np.vectorize(lambda func, arg: func(arg))
output = vec_apply(f, a)
print(output)

Quick Decision Guide #

• Small/fast functions + large list: Use Numba to eliminate loop overhead.
• Slow/CPU-heavy functions: Use parallel execution.
• Just want numpy-style code: Stick with numpy.vectorize or a list comprehension (they’re equally fast here).

内容的提问来源于stack exchange，提问作者Jesper - jtk.eth