纯Python比Numpy更快吗？我可以使这个numpy代码更快吗？

Question

我需要从特定的面/顶点列表中计算最小值，最大值和平均值。我试图用Numpy优化这个计算，但没有成功。

这是我的测试用例：

#!/usr/bin/python 
# -*- coding: iso-8859-15 -*- 
''' 
Module Started 22 févr. 2013 
@note: test case comparaison numpy vs python 
@author: Python4D/damien 
''' 

import numpy as np 
import time 


def Fnumpy(vertices): 
    np_vertices=np.array(vertices) 
    _x=np_vertices[:,:,0] 
    _y=np_vertices[:,:,1] 
    _z=np_vertices[:,:,2] 
    _min=[np.min(_x),np.min(_y),np.min(_z)] 
    _max=[np.max(_x),np.max(_y),np.max(_z)] 
    _mean=[np.mean(_x),np.mean(_y),np.mean(_z)] 
    return _mean,_max,_min 

def Fpython(vertices): 
    list_x=[item[0] for sublist in vertices for item in sublist] 
    list_y=[item[1] for sublist in vertices for item in sublist] 
    list_z=[item[2] for sublist in vertices for item in sublist] 
    taille=len(list_x) 
    _mean=[sum(list_x)/taille,sum(list_y)/taille,sum(list_z)/taille] 
    _max=[max(list_x),max(list_y),max(list_z)] 
    _min=[min(list_x),min(list_y),min(list_z)]  
    return _mean,_max,_min 

if __name__=="__main__": 
    vertices=[[[1.1,2.2,3.3,4.4]]*4]*1000000 
    _t=time.clock() 
    print ">>NUMPY >>{} for {}s.".format(Fnumpy(vertices),time.clock()-_t) 
    _t=time.clock() 
    print ">>PYTHON>>{} for {}s.".format(Fpython(vertices),time.clock()-_t) 

的结果是：

numpy的：

（[1.1000000000452519，2.2000000000905038，3.3000000001880174]，[1.1000000000000001，2.2000000000000002，3.2999999999999998 ]，[1.1000000000000001,2.2000000000000002,3.2999999999999998]）为27.327068618s。

的Python：

（[1.100000000045252，2.200000000090504，3.3000000001880174]，[1.1，2.2，3.3]，[1.1，2.2，3.3]）为1.81366938593s。

纯Python的速度比Numpy快15倍！

Answer 1

你的Fnumpy较慢的原因是它包含一个不由Fpython完成的额外步骤：在内存中创建一个numpy数组。如果招行np_verticies=np.array(verticies)的Fnumpy外部和定时部分的结果将有很大的不同：

>>NUMPY >>([1.1000000000452519, 2.2000000000905038, 3.3000000001880174], [1.1000000000000001, 2.2000000000000002, 3.2999999999999998], [1.1000000000000001, 2.2000000000000002, 3.2999999999999998]) for 0.500802s. 
>>PYTHON>>([1.100000000045252, 2.200000000090504, 3.3000000001880174], [1.1, 2.2, 3.3], [1.1, 2.2, 3.3]) for 2.182239s. 

您还可以通过提供的数据类型的提示，当您创建它numpy的显著加快分配步骤。如果你告诉Numpy你有一组浮点数，那么即使你在定时循环中保持np.array()的调用，它也会打败纯Python版本。

如果我改变np_vertices=np.array(vertices)到np_vertices=np.array(vertices, dtype=np.float_)和保持在Fnumpy，在Fnumpy版本将击败Fpython即使它有做了很多工作：

>>NUMPY >>([1.1000000000452519, 2.2000000000905038, 3.3000000001880174], [1.1000000000000001, 2.2000000000000002, 3.2999999999999998], [1.1000000000000001, 2.2000000000000002, 3.2999999999999998]) for 1.586066s. 
>>PYTHON>>([1.100000000045252, 2.200000000090504, 3.3000000001880174], [1.1, 2.2, 3.3], [1.1, 2.2, 3.3]) for 2.196787s. 

Answer 2

正如所指出的其他人，你的问题是从列表到数组的转换。通过使用适当的numpy函数，你将击败Python。我修改程序的主要组成部分：

if __name__=="__main__": 
    _t = time.clock() 
    vertices_np = np.resize(np.array([ 1.1, 2.2, 3.3, 4.4 ], dtype=np.float64), 
          (1000000, 4, 4)) 
    print "Creating numpy vertices: {}".format(time.clock() - _t) 
    _t = time.clock() 
    vertices=[[[1.1,2.2,3.3,4.4]]*4]*1000000 
    print "Creating python vertices: {}".format(time.clock() - _t) 
    _t=time.clock() 
    print ">>NUMPY >>{} for {}s.".format(Fnumpy(vertices_np),time.clock()-_t) 
    _t=time.clock() 
    print ">>PYTHON>>{} for {}s.".format(Fpython(vertices),time.clock()-_t) 

与我的机器在体改主要部分结果运行代码：

Creating numpy vertices: 0.6 
Creating python vertices: 0.01 
>>NUMPY >>([1.1000000000452519, 2.2000000000905038, 3.3000000001880174], 
[1.1000000000000001, 2.2000000000000002, 3.2999999999999998], [1.1000000000000001, 
2.2000000000000002, 3.2999999999999998]) for 0.5s. 
>>PYTHON>>([1.100000000045252, 2.200000000090504, 3.3000000001880174], [1.1, 2.2, 3.3], 
[1.1, 2.2, 3.3]) for 1.91s. 

虽然数组创建仍与numpy的工具为略长使用python的列表乘法运算符（0.6s对0.01s）创建嵌套列表，可以获得ca的一个因子。 4代表您的代码的运行时相关部分。如果我更换行：

np_vertices = np.asarray(vertices) 

避免大阵列的复制

np_vertices=np.array(vertices) 

，该numpy的功能的运行时间甚至下降到0.37s我的机器上，比多比纯Python版本快5倍。

在你真实的代码中，如果你事先知道顶点的数量，你可以通过np.empty()预先分配合适的数组，然后用合适的数据填充它，并将它传递给函数的numpy版本。