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

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 <=
100基本上是瞬时的。所以我决定将其移植到python，因为我想使用SqlAlchemy来做其他事情。

我首先移植了它，但没有现在可以使用该方法的deepcopy语句，这导致结果“奇数”或部分不正确，因为某些要点只是被复制为引用（我猜？我想吗？）-但是它仍然几乎与C版本一样快。

现在添加了deepcopy调用后，该例程可以正确执行其工作，但是却造成了极大的性能损失，并且现在需要几秒钟来完成相同的工作。

这似乎是一项很普通的工作，但是我显然不是以pythonic的方式来做。我应该如何做才能使我仍然获得正确的结果，而不必到处都包含Deepcopy？

编辑：
我已经找到了一个更简单，更快速的解决方案，

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

因此，基本上，我只是复制输入内容并附加一个新值-
距参考点的距离。然后，我仅将“已排序”应用于结果列表，并指定排序键应为PointDistance对象的distance属性。

尽管我承认我不太了解为什么，但这比使用Deepcopy快得多。我想这取决于有效的C实现python的“排序”吗？

Answer 1

好的，首先要做最简单的事情：

1. deepcopy通常，它很慢，因为它必须进行大量内部记账来复制病理性案例，例如以理智的方式包含其自身的对象。见，例如，该页面，或者看看的源代码deepcopy中copy.py是在你的Python路径的某处。

2. 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指向新数字。简而言之，数字，字符串和元组是不可变的；列表，字典和集合是可变的。用户定义的类通常是可变的，除非您明确确保内部状态不能突变。还有frozenset，这是一个不变的集合。当然还有其他很多：)

我不知道为什么您的原始代码不起作用，但是您可能遇到了与我在列表中显示的代码段有关的行为，因为PointDistance默认情况下您的类也是可变的。一个替代方法是namedtuplefrom的类collections，该类构造一个类似元组的对象，其字段也可以通过名称进行访问。例如，您可以这样做：

from collections import namedtuple
PointDistance = namedtuple("PointDistance", "point distance")

这会PointDistance为您创建一个具有两个命名字段的类：point和distance。在主for循环中，您可以适当地分配它们。由于point字段指向的点对象在for循环过程中不会被修改，distance而是一个数字（根据定义，它是不可变的），因此您应该放心地这样做。但是是的，总的来说，由于使用了C语言，因此使用起来似乎sorted更快sorted。您可能还很幸运使用该heapq模块，该模块实现了由普通Python列表支持的堆数据结构，因此可以k轻松地找到顶部元素无需对其他排序。但是，由于heapq也是在Python中实现的，因此很有可能sorted
除非您有很多要点，否则效果会更好。

最后，我想补充一点，就是deepcopy到目前为止我从来没有用过，所以我想在大多数情况下有避免这种情况的方法。