python生成一个数组_python-Cython中从现有数组和变量创建新数组...

与“普通” Python相比,Cython为我们提供了更多对array.array内部的访问,因此我们可以利用它来加速代码：

>对于您的小示例,几乎减少了7倍(消除了大部分开销).

对于较大的输入,通过消除不必要的数组副本,将其乘以2.

请阅读以获得更多详情.

尝试针对如此小的输入优化功能是有点不寻常的,但并非没有(至少是理论上的)兴趣.

因此,让我们从您的函数作为基线开始：

a=array('l', [1,2,3])

%timeit pyappend(a, 8)

1.03 ?s ± 10.4 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

lst=[1,2,3]

%timeit pylistappend(lst, 8)

279 ns ± 6.03 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

我们必须意识到：我们要衡量的不是复制成本而是开销成本(python解释器,调用函数等),例如a包含3个元素还是5个元素没有什么区别：

a=array('l', range(5))

%timeit pyappend(a, 8)

1.03 ?s ± 6.76 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

在数组版本中,我们有更多的开销,因为我们通过复制模块进行了间接访问,我们可以尝试消除这种情况：

def pyappend2(arr, x):

result = array('l',arr)

result.append(x)

return result

%timeit pyappend2(a, 8)

496 ns ± 5.04 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

那更快.现在让我们使用cython-这将消除翻译程序的成本：

%%cython

def cylistappend(lst, x):

result = lst[:]

result.append(x)

return result

%%cython

from cpython cimport array

def cyappend(array.array arr, long long int x):

cdef array.array res = array.array('l', arr)

res.append(x)

return res

%timeit cylistappend(lst, 8)

193 ns ± 12.4 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

%%timeit cyappend(a, 8)

421 ns ± 8.08 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

cython版本的列表大约快33％,阵列大约快10％.构造函数array.array()期望可迭代,但是我们已经有了array.array,因此我们使用cpython中的功能来访问array.array对象的内部,并稍微改善这种情况：

%%cython

from cpython cimport array

def cyappend2(array.array arr, long long int x):

cdef array.array res = array.copy(arr)

res.append(x)

return res

%timeit cyappend2(a, 8)

305 ns ± 7.25 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

下一步,我们需要知道array.array如何追加元素：通常为it over-allocates,所以append()的摊销成本为O(1),但是在array.copy之后,新数组恰好是所需数量的元素,下一个追加调用重新分配.我们需要进行更改(有关使用的功能的说明,请参见here)：

%%cython

from cpython cimport array

from libc.string cimport memcpy

def cyappend3(array.array arr, long long int x):

cdef Py_ssize_t n=len(arr)

cdef array.array res = array.clone(arr,n+1,False)

memcpy(res.data.as_voidptr, arr.data.as_voidptr, 8*n)#that is pretty sloppy..

res.data.as_longlongs[n]=x

return res

%timeit cyappend3(a, 8)

154 ns ± 1.34 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

与您的函数类似,内存已过度分配,因此我们不再需要调用resize().现在我们比列表快,比原始python版本快近7倍.

让我们比较一下更大数组大小的时序(a = array(‘l’,range(1000)),lst = list(range(1000))),其中数据的复制占据了大部分运行时间：

pyappend 1.84 ?s #copy-module is slow!

pyappend2 1.02 ?s

cyappend 0.94 ?s #cython no big help - we are copying twice

cyappend2 0.90 ?s #still copying twice

cyappend3 0.43 ?s #copying only once -> twice as fast!

pylistappend 4.09 ?s # needs to increment refs of integers

cylistappend 3.85 ?s # the same as above

现在,消除不必要的array.array副本可以得到预期的因子2.

对于更大的数组(10000个元素),我们看到以下内容：

pyappend 6.9 ?s #copy-module is slow!

pyappend2 4.8 ?s

cyappend2 4.4 ?s

cyappend3 4.4 ?s

两个版本之间不再存在差异(如果放弃慢速复制模块).这样做的原因是对如此大量元素的array.array的行为发生了改变：复制时,它会过度分配,从而避免了在第一个append()之后进行重新分配.

我们可以轻松地检查它：

b=array('l', array('l', range(10**3)))#emulate our functions

b.buffer_info()

[] (94481422849232, 1000)

b.append(1)

b.buffer_info()

[] (94481422860352, 1001) # another pointer address -> reallocated

...

b=array('l', array('l', range(10**4)))

b.buffer_info()

[](94481426290064, 10000)

b.append(33)

b.buffer_info()

[](94481426290064, 10001) # the same pointer address -> no reallocation!