我有一个非常简单的python例程,它涉及在大约20,000个纬度,经度坐标的列表中循环并计算每个点到参考点的距离.
def compute_nearest_points( lat, lon, nPoints=5 ):
"""Find the nearest N points, given the input coordinates."""
points = session.query(PointIndex).all()
oldNearest = []
newNearest = []
for n in xrange(nPoints):
oldNearest.append(PointDistance(None,None,None,99999.0,99999.0))
newNearest.append(obj2)
#This is almost certainly an inappropriate use of deepcopy
# but how SHOULD I be doing this?!?!
for point in points:
distance = compute_spherical_law_of_cosines( lat, lon, point.avg_lat, point.avg_lon )
k = 0
for p in oldNearest:
if distance < p.distance:
newNearest[k] = PointDistance(
point.point, point.kana, point.english, point.avg_lat, point.avg_lon, distance=distance
)
break
else:
newNearest[k] = deepcopy(oldNearest[k])
k += 1
for j in range(k,nPoints-1):
newNearest[j+1] = deepcopy(oldNearest[j])
oldNearest = deepcopy(newNearest)
#We're done, now print the result
for point in oldNearest:
print point.station, point.english, point.distance
return
我最初使用完全相同的方法在C中写了这个,并且它在那里工作正常,并且对于nPoints <= 100基本上是瞬时的.所以我决定将它移植到python,因为我想使用SqlAlchemy来做其他一些事情.
我首先移植它而不使用深度复制语句,现在对方法进行了改进,这导致结果"奇怪"或部分不正确,因为有些点只是被复制为引用(我猜？我想？) - 但它仍然几乎和C版一样快.
现在添加了deepcopy调用,例程正确地完成了它的工作,但它已经造成了极大的性能损失,现在需要几秒钟来完成同样的工作.
这似乎是一项相当普遍的工作,但我显然不是以pythonic方式做的.我应该如何做到这一点,以便我仍然得到正确的结果,但不必在任何地方都包括深度复制？
编辑:
我已经找到了一个更简单,更快速的解决方案,
def compute_nearest_points2( lat, lon, nPoints=5 ):
"""Find the nearest N points, given the input coordinates."""
points = session.query(PointIndex).all()
nearest = []
for point in points:
distance = compute_spherical_law_of_cosines( lat, lon, point.avg_lat, point.avg_lon )
nearest.append(
PointDistance(
point.point, point.kana, point.english, point.avg_lat, point.avg_lon, distance=distance
)
)
nearest_points = sorted(nearest, key=lambda point: point.distance)[:nPoints]
for item in nearest_points:
print item.point, item.english, item.distance
return
所以基本上我只是制作输入的完整副本并附加一个新值 - 距参考点的距离.然后我只是将'sorted'应用于结果列表,指定sort键应该是PointDistance对象的distance属性.
这比使用deepcopy快得多,尽管我承认我并不真正理解为什么.我想这是有效的C实现python的"排序"？
Tam*_*más 33
好的,最简单的事情:
deepcopy一般来说很慢,因为它必须做大量的内部簿记来复制病理案例,比如以理智的方式包含自己的对象.见,例如,该页面,或者看看的源代码deepcopy中copy.py是在你的Python路径的某处.
sorted 很快,因为它是用C实现的.比Python中的同等排序要快得多.
现在,正如您在评论中提到的那样,更多关于Python的引用计数行为的事情.在Python中,变量是引用.当你说a=1,想想它有1一个独立存在的对象,并且a只是一个附加到它的标签.在像C这样的其他语言中,变量是容器(而不是标签),当你这样做时a=1,实际上是1 a.这不适用于Python,其中变量是引用.这有一些有趣的后果,你可能也偶然发现:
>>> a = [] # construct a new list, attach a tag named "a" to it
>>> b = a # attach a tag named "b" to the object which is tagged by "a"
>>> a.append(1) # append 1 to the list tagged by "a"
>>> print b # print the list tagged by "b"
[1]
可以看到此行为,因为列表是可变对象:您可以在创建列表后修改列表,并在通过引用它的任何变量访问列表时看到修改.列表的不可变等价物是元组:
>>> a = () # construct a new tuple, attach a tag named "a" to it
>>> b = a # now "b" refers to the same empty tuple as "a"
>>> a += (1, 2) # appending some elements to the tuple
>>> print b
()
在这里,a += (1, 2)创建了一个新的从现有的元组的元组提到了a,加上又是元组(1, 2)是在即时构建,并a调整为指向新的元组,当然同时b还指的是旧的元组.简单的数字加法也是如此a = a+2:在这种情况下,最初指向的数字a不会以任何方式变异,Python"构造"一个新数字并移动a指向新数字.所以,简而言之:数字,字符串和元组是不可变的; 列表,dicts和集是可变的.用户定义的类通常是可变的,除非您明确确保内部状态不能被突变.而且frozenset,这是一个不可改变的集合.当然还有很多其他:)
我不知道为什么你原来的代码没有工作,但可能你打与我和列表显示该代码段的行为,你的PointDistance类也是默认可变的.另一种可能是namedtuple从类collections,它构建了一个元组类对象,其领域也可以通过名称访问.例如,你可以这样做:
from collections import namedtuple
PointDistance = namedtuple("PointDistance", "point distance")
这就产生了一个PointDistance对你来说有两个命名字段级:point和distance.在主for循环中,您可以适当地分配这些.由于point字段指向的点对象在for循环过程中不会被修改,并且distance是一个数字(根据定义,它是不可变的),你应该这样安全.但是,总的来说,似乎只是使用sorted更快,因为sorted在C中实现.您可能也很幸运,该heapq模块实现了由普通Python列表支持的堆数据结构,因此它可以让您k轻松找到顶层元素而不必排序其他人.但是,既然heapq也是用Python实现的,那很有可能sorted 除非你有很多积分,否则效果会更好.
最后,我想补充说我deepcopy到目前为止从未使用过,所以我想在大多数情况下都有办法避免它.
我知道这并没有直接解决你的问题(我知道这是一个老问题),但由于有一些关于性能的讨论,所以看一下这个append操作可能是值得的.您可能需要考虑"预分配"数组.例如:
array = [None] * num_elements
for i in range(num_elements):
array[i] = True
与:
array = []
for i in range(num_elements):
array.append(True)
timeit如果预先分配数组甚至适中的值,那么这两种方法的简单运行显示了25%的改进num_elements.