Python numpy array fromfunction使用前一个值作为输入，初始值为非零

我想使用函数用值填充numpy数组。我希望数组从一个初始值开始并填充到给定的长度，使用数组中以前的每个值作为函数的输入

每个数组值i应为i-1*x**y/z

经过一点工作，我必须：

import numpy as np
f = np.zeros([31,1])
f[0] = 20
fun = lambda i, j: i*2**(1/3)
f[1:] = np.fromfunction(np.vectorize(fun), (len(f)-1,1), dtype = int)

这将使用

[firstvalue=20,0，i-1+1*2**1/3，…]

我到这儿来读过书

---

但我只是不知道如何将它转换为我的函数。

除了最初的20，这会产生相同的值

np.arange(31)*2**(1/3)

您的迭代版本稍有修改

def foo0(n):
    f = np.zeros(n)
    f[0] = 20
    for i in range(1,n): 
        f[i] = f[i-1]*2**(1/3)
    return f

另一种选择：

def foo1(n):
    g = [20]
    for i in range(n-1):
        g.append(g[-1]*2**(1/3))
    return np.array(g)

他们生产同样的东西：

In [25]: np.allclose(foo0(31), foo1(31))
Out[25]: True

我的要快一点：

In [26]: timeit foo0(100)
35 µs ± 75 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
In [27]: timeit foo1(100)
23.6 µs ± 83.6 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

但我们不需要每次评估2**1/3

def foo2(n):
    g = [20]
    const = 2**(1/3)
    for i in range(n-1):
        g.append(g[-1]*const)
    return np.array(g)

节省少量时间。但这只是将每个条目乘以相同的常数。因此，我们可以使用cumprod来节省更多的时间：

def foo3(n):
    g = np.ones(n)*(2**(1/3))
    g[0]=20
    return np.cumprod(g)

In [37]: timeit foo3(31)
14.9 µs ± 14.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [40]: np.allclose(foo0(31), foo3(31))
Out[40]: True

---

谢谢，但即使第一个值是20，这也不会使用第i-1个值来计算i。向我们展示如何通过迭代进行计算。正如我的回答所示，函数中的链接并不能帮助您编写迭代代码。它只需通过一次调用将函数应用于整个索引集。矢量化也没有帮助。这只是一种将多个数组广播到只接受标量的函数的方便方法。这两种方法都不能保证速度。谢谢，当我今天醒来的时候，我意识到不可能将这种操作矢量化，因为这会违反因果关系；函数在计算i-1之前无法知道i-1的值是什么，因此必须通过一系列迭代运算来计算i的下一个值。我觉得自己很愚蠢。我将尝试迭代它并重新发布。对于np中的I.linspace1，lenf-1，lenf-1，dtype=int:f[I]=f[I-1]*2**1/3Doesn看起来不太像python，更像matlabby，但这就是我的来源……迭代非常python；这就是一直处理列表的方式。MATLAB过去要求“矢量化”，其意义与numpy相同；但是他们后来添加了jit编译，这减少了从整个数组的角度考虑问题的需要``numba`和cython可以达到同样的效果。