Python 将具有多个输入的函数矢量化以形成唯一函数

np.sin()已经矢量化，因为它将在数组上工作

>>> np.sin(np.array([1,2,3]))
array([0.84147098, 0.90929743, 0.14112001])

您可以直接调用您的函数

def signal_prototype(t, A, f, p):
    return A*np.sin(2*np.pi*f*t+p)

t = np.linspace(0,1e-3,100000)

X1 = signal_prototype(t=t, A=1, f=10000, p=0)
X2 = signal_prototype(t=t, A=1, f=10000, p=np.pi/4)
X3 = signal_prototype(t=t, A=1, f=10000, p=np.pi/2)
X4 = signal_prototype(t=t, A=1, f=10000, p=3*np.pi/4)

如果要 for each 函数创建一个单独的函数，可以按照建议使用lambda或functools.partial

signal_A = lambda t: signal_prototype(t=t, A=1, f=10000, p=0)
signal_B = lambda t: signal_prototype(t=t, A=1, f=10000, p=np.pi/4)
signal_C = lambda t: signal_prototype(t=t, A=1, f=10000, p=np.pi/2)
signal_D = lambda t: signal_prototype(t=t, A=1, f=10000, p=3*np.pi/4)

X1 = signal_A(t)
X2 = signal_B(t)
X3 = signal_C(t)
X4 = signal_D(t)

或者自己返回分部函数(实际上与lambda相同)

def wrapper(func, **kwargs):
    def wrapped(t):
        return func(t, **kwargs)            
    return wrapped

signal_A = wrapper(signal_prototype, A=1, f=10000, p=0)
signal_B = wrapper(signal_prototype, A=1, f=10000, p=np.pi/4)
signal_C = wrapper(signal_prototype, A=1, f=10000, p=np.pi/2)
signal_D = wrapper(signal_prototype, A=1, f=10000, p=3*np.pi/4)

如果您想要传递默认的t或使其成为可选的，您可以扩展它，尽管我不建议这样做，只是让它来说明它有多强大，因为返回不同类型的东西从来都不是明智之举(如带有可变数量参数的IMO函数)

do not do this个

def wrapper(func, t=None, **kwargs):
    if t is not None:
        def wrapped(t=t):
            return func(t, **kwargs)
    else:
        def wrapped(t):
            return func(t, **kwargs)
    return wrapped

>>> wrapper(signal_prototype, A=1, f=10000, p=0)(t)
array([ 0.00000000e+00,  6.28324773e-04,  1.25664930e-03, ...,
       -1.25664930e-03, -6.28324773e-04, -2.44929360e-15])
>>> wrapper(signal_prototype, t=t, A=1, f=10000, p=0)()
array([ 0.00000000e+00,  6.28324773e-04,  1.25664930e-03, ...,
       -1.25664930e-03, -6.28324773e-04, -2.44929360e-15])