迭代或使用索引逐个元素访问numpy数组效率很低（请参考Why is for loop on native python list faster than for loop on numpy array）。考虑使用numpy的内置函数或方法来加速循环，这可以显着提高大型数组的性能：

def mechanic_using_numpy(N):
    y = np.empty(N, float)
    y[:1] = 1.0
    y[1:] = 0.5
    y.cumprod(out=y)
    np.subtract(1, y, out=y)
    return y

个字符
使用N = 100000进行基准测试：

In [_]: %timeit using_numpy(100000)
44.6 ms ± 227 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [_]: %timeit using_list(100000)
14.3 ms ± 38.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [_]: %timeit mechanic_using_numpy(100000)
286 µs ± 875 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

型

为了从numpy中获得好处，您需要以不同的方式进行计算。将其视为对所有值的全局操作，而不是迭代计算：
例如，这个函数给出了相同的结果，但运行速度比使用列表快25倍：

def using_np(N):
    return 1 - 0.5**(np.arange(N))

字符串
如果您需要更快的速度，您可以合并更简单的操作（例如加法和乘法而不是取幂）：

def using_np2(N):
    y      = np.ones(N)
    y[0]   = 0
    y[1:] -= np.cumprod(y[1:]/2)
    return y

型

• 这个比列表快40倍 *

当Numpy可以隐式地并行化操作时，它是快速的。如果没有y[i-1] -> y[i]数据依赖项，可以替换如下循环

for i in range(N):
    y[i] = 0.5*x[i]

字符串
与

y = 0.5*x

型
迭代数组的元素并不比迭代列表的元素更快，实际上由于需要在Numpy值类型和Python原生类型之间来回转换，因此速度稍慢。
例如，float值的列表只是引用的列表。y[i]是对存在于列表之外的float值的引用。然而，dtype的float64数组只是一个表示浮点值集合的二进制blob。像y[i]这样的操作必须提取适当的位，然后使用它们来 * 创建 * 一个要返回的float值。更复杂的表达式，如

y[i] = x[i] + 0.5 * (y[i-1] - x[i])

型
需要从x和y中提取 * 三个 * 这样的值，执行与列表方法相同的运算，然后将结果转换回字节序列以插入回y。
对于y = 0.5*x，不存在字节序列到float值的转换，不使用float.__mul__，也不转换回字节序列。所有算法都在Numpy的优化C代码中内部完成。