python计算复制比_什么是深度复制python dict或列表中的数据的快速pythonic方法？...

这真的取决于你的需求。深度复制的目的是做(最)正确的事情。它保持共享引用，它不会递归到无限递归结构等等……它可以通过保留备注字典来实现，其中所有遇到的“事物”都通过引用插入。这就是纯数据副本速度慢的原因。然而，我几乎总是说深度复制是复制数据的最pythonic方式，即使其他方法可能更快。

如果你有纯数据和有限数量的类型，你可以构建自己的深度复制(大致在deepcopy in CPython实现后构建)：

_dispatcher = {}

def _copy_list(l, dispatch):

ret = l.copy()

for idx, item in enumerate(ret):

cp = dispatch.get(type(item))

if cp is not None:

ret[idx] = cp(item, dispatch)

return ret

def _copy_dict(d, dispatch):

ret = d.copy()

for key, value in ret.items():

cp = dispatch.get(type(value))

if cp is not None:

ret[key] = cp(value, dispatch)

return ret

_dispatcher[list] = _copy_list

_dispatcher[dict] = _copy_dict

def deepcopy(sth):

cp = _dispatcher.get(type(sth))

if cp is None:

return sth

else:

return cp(sth, _dispatcher)

这仅适用于所有不可变的非容器类型以及list和dict实例。如果需要，可以添加更多调度程序。

# Timings done on Python 3.5.3 - Windows - on a really slow laptop :-/

import copy

import msgpack

import json

import string

data = {'name':'John Doe','ranks':{'sports':13,'edu':34,'arts':45},'grade':5}

%timeit deepcopy(data)

# 11.9 µs ± 280 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit copy.deepcopy(data)

# 64.3 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

%timeit json.loads(json.dumps(data))

# 65.9 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

%timeit msgpack.unpackb(msgpack.packb(data))

# 56.5 µs ± 2.53 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

让我们看看它在复制包含字符串和整数的大字典时的表现如何：

data = {''.join([a,b,c]): 1 for a in string.ascii_letters for b in string.ascii_letters for c in string.ascii_letters}

%timeit deepcopy(data)

# 194 ms ± 5.37 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

%timeit copy.deepcopy(data)

# 1.02 s ± 46.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit json.loads(json.dumps(data))

# 398 ms ± 20.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit msgpack.unpackb(msgpack.packb(data))

# 238 ms ± 8.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)