Question

我有一个非常简单的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＆lt; = 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'应用于结果列表，指定排序键应该是PointDistance对象的distance属性。

这比使用deepcopy要快得多，尽管我承认我并不理解为什么。我想这是有效的C实现python的“排序”？

Answer 1

好的，首先是最简单的事情：

deepcopy一般来说很慢，因为它必须进行大量的内部簿记来复制病态案例，例如以理智的方式包含自己的对象。例如，请参阅this page，或者查看Python路径中某处deepcopy中copy.py的源代码。
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]

可以看到此行为，因为列表是可变对象：您可以在创建列表后修改列表，并在通过引用它的任何变量访问列表时看到修改。列表的 immutable 等价物是元组：

>>> 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引用的现有元组创建一个 new 元组，以及另一个即时构建的元组(1, 2) ，a被调整为指向新元组，当然b仍然指旧元组。像a = a+2这样的简单数字加法也是如此：在这种情况下，a最初指向的数字不会以任何方式发生变异，Python“构造”一个新数字并移动a指向新号码。所以，简而言之：数字，字符串和元组是不可变的;列表，dicts和集是可变的。用户定义的类通常是可变的，除非您明确确保内部状态不能被突变。还有frozenset，这是一个不可变的集合。当然还有很多其他人：）

我不知道为什么你的原始代码不起作用，但是你可能会遇到与我用列表显示的代码片段相关的行为，因为你的PointDistance类在默认情况下也是可变的。替代方案可以是来自namedtuple的{{1}}类，它构造一个类似元组的对象，其字段也可以通过名称访问。例如，你可以这样做：

collections

这将为您创建一个from collections import namedtuple PointDistance = namedtuple("PointDistance", "point distance")类，其中包含两个命名字段：PointDistance和point。在主distance循环中，您可以适当地分配这些。由于for字段指向的点对象在point循环过程中不会被修改，for是一个数字（根据定义，它是不可变的），这样做你应该安全。但是，总的来说，似乎简单地使用distance更快，因为sorted在C中实现。您可能也很幸运使用sorted模块，该模块实现了支持的堆数据结构通过普通的Python列表，它可以让您轻松找到顶级heapq元素，而无需对其他元素进行排序。但是，由于k也是在Python中实现的，因此除非你有很多分数，否则heapq可能会更好。

最后，我想补充一点，到目前为止我从未使用sorted，所以我想在大多数情况下都有办法避免它。

Answer 2

我知道这并没有直接解决你的问题（我知道这是一个老问题），但由于有一些关于性能的讨论，所以看看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的中等值预先分配数组，这两种方法的简单num_elements运行会显示25％的改进。

deepcopy和python - 避免使用它的提示？

2 个答案: