是否有等同于使用扩充分配的内建sum（）？

Question

是否存在与以下函数等效的标准库/ numpy：

def augmented_assignment_sum(iterable, start=0):
    for n in iterable:
        start += n
    return start

？

虽然sum(ITERABLE)非常优雅，但它使用+运算符而不是+=，在np.ndarray对象的情况下，这可能会影响性能。

我已经测试过我的功能可能与sum()一样快（而使用+的等效速度要慢得多）。由于它是纯Python函数，因此我认为它的性能仍然受到限制，因此我正在寻找其他选择：

In [49]: ARRAYS = [np.random.random((1000000)) for _ in range(100)]

In [50]: def not_augmented_assignment_sum(iterable, start=0): 
    ...:     for n in iterable: 
    ...:         start = start + n 
    ...:     return start 
    ...:                                                                                                                                                                                                                                                                       

In [51]: %timeit not_augmented_assignment_sum(ARRAYS)                                                                                                                                                                                                                          
63.6 ms ± 8.88 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [52]: %timeit sum(ARRAYS)                                                                                                                                                                                                                                                   
31.2 ms ± 2.18 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [53]: %timeit augmented_assignment_sum(ARRAYS)                                                                                                                                                                                                                              
31.2 ms ± 4.73 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [54]: %timeit not_augmented_assignment_sum(ARRAYS)                                                                                                                                                                                                                          
62.5 ms ± 12.1 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [55]: %timeit sum(ARRAYS)                                                                                                                                                                                                                                                   
37 ms ± 9.51 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [56]: %timeit augmented_assignment_sum(ARRAYS)                                                                                                                                                                                                                              
27.7 ms ± 2.53 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

我曾尝试将functools.reduce与operator.iadd结合使用，但其性能相似：

In [79]: %timeit reduce(iadd, ARRAYS, 0)                                                                                                                                                                                                                                       
33.4 ms ± 11.6 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [80]: %timeit reduce(iadd, ARRAYS, 0)                                                                                                                                                                                                                                       
29.4 ms ± 2.31 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

我也对内存效率感兴趣，因此更喜欢扩展分配，因为它们不需要创建中间对象。

是否有以下函数的任何标准库/ numpy等效项：def extendeded_assignment_sum（iterable，start = 0）：对于n中的iterable：start + = n返回start吗？而sum（...

Answer 1

标题问题的答案---我希望@Martijn Pieters会原谅我对隐喻的选择---从马口中直接得出的是：不，没有这样的内置函数。