相关疑难解决方法(0)

当我们需要从包含原始数据类型的字典中复制完整数据时(为简单起见,让我们忽略数据类型的存在,比如datetime等),我们最明显的选择是使用deepcopy,但深度复制比其他一些实现的hackish方法要慢相同的,例如使用序列化 - 非序列化,例如json-dump-json-load或msgpack-pack-msgpack-unpack.效率的差异可以在这里看到:

>>> import timeit
>>> setup = '''
... import msgpack
... import json
... from copy import deepcopy
... data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}
... '''
>>> print(timeit.timeit('deepcopy(data)', setup=setup))
12.0860249996
>>> print(timeit.timeit('json.loads(json.dumps(data))', setup=setup))
9.07182312012
>>> print(timeit.timeit('msgpack.unpackb(msgpack.packb(data))', setup=setup))
1.42743492126

json和msgpack(或cPickle)方法比普通的深度复制更快,这很明显,因为深度复制在复制对象的所有属性方面也会做得更多.

问题:是否有一种更加pythonic /内置的方式来实现字典或列表的数据副本,而没有深度复制所具有的所有开销？

我有一个非常简单的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 …

我正在寻找一个包含类对象列表的类对象的深层副本，每个类对象都有自己的一组内容。这些对象不包含任何比整数和列表更令人兴奋的东西（没有字典，没有等待生成的生成器等）。我正在一个循环中对 500-800 个对象执行深度复制，这确实减慢了程序速度。我意识到这已经是低效了；目前无法更改。

其外观示例：

import random
import copy

class Base:
    def __init__(self, minimum, maximum, length):
        self.minimum = minimum
        self.maximum = maximum
        self.numbers = [random.randint(minimum, maximum) for _ in range(length)]
        # etc

class Next:
    def __init__(self, minimum, maximum, length, quantity):
        self.minimum = minimum
        self.maximum = maximum
        self.bases = [Base(minimum, maximum, length) for _ in range(quantity)]
        # etc

由于我对对象执行的操作，我无法浅复制。我需要新变量拥有的内容：

> first = Next(0, 10, 5, 10)
> second = first
> first.bases[0].numbers[1] = 4
> print(first.bases[0].numbers)
> [2, 4, 3, 3, 8] …

我一直在开发一个性能关键的应用程序，该应用程序需要经常需要制作二维整数列表的副本并修改副本（我正在实现极小极大算法）。

我注意到在具有相同数量元素的列表上，副本和深度复制之间的性能存在巨大差异，我想了解我的想法是否正确。

要重现我的问题，请运行以下代码：

import numpy as np\n\nnp.random.seed(0)\nlst1 = np.random.randint(100, size=1000 * 1000).tolist()\nlst2 = np.random.randint(100, size=(1000, 1000)).tolist()\n

现在，对下面的语句进行计时，您应该会看到与我类似的计时。

%timeit copy.copy(lst1)\n%timeit lst1.copy()\n%timeit copy.deepcopy(lst2)\n\n5 ms \xc2\xb1 49.7 \xc2\xb5s per loop (mean \xc2\xb1 std. dev. of 7 runs, 100 loops each)\n5.47 ms \xc2\xb1 551 \xc2\xb5s per loop (mean \xc2\xb1 std. dev. of 7 runs, 100 loops each)\n1.61 s \xc2\xb1 112 ms per loop (mean \xc2\xb1 std. dev. of 7 runs, 1 loop each)\n

和lst1都有 …