2000-02-04 23:39:30 +08:00
|
|
|
"""Generic (shallow and deep) copying operations.
|
1995-01-10 08:34:21 +08:00
|
|
|
|
1995-02-10 01:18:10 +08:00
|
|
|
Interface summary:
|
|
|
|
|
2001-01-15 07:36:06 +08:00
|
|
|
import copy
|
1995-02-10 01:18:10 +08:00
|
|
|
|
2001-01-15 07:36:06 +08:00
|
|
|
x = copy.copy(y) # make a shallow copy of y
|
|
|
|
x = copy.deepcopy(y) # make a deep copy of y
|
1995-02-10 01:18:10 +08:00
|
|
|
|
2003-02-07 03:53:22 +08:00
|
|
|
For module specific errors, copy.Error is raised.
|
1995-02-10 01:18:10 +08:00
|
|
|
|
|
|
|
The difference between shallow and deep copying is only relevant for
|
|
|
|
compound objects (objects that contain other objects, like lists or
|
|
|
|
class instances).
|
|
|
|
|
|
|
|
- A shallow copy constructs a new compound object and then (to the
|
2005-06-13 09:10:15 +08:00
|
|
|
extent possible) inserts *the same objects* into it that the
|
1995-02-10 01:18:10 +08:00
|
|
|
original contains.
|
|
|
|
|
|
|
|
- A deep copy constructs a new compound object and then, recursively,
|
|
|
|
inserts *copies* into it of the objects found in the original.
|
|
|
|
|
|
|
|
Two problems often exist with deep copy operations that don't exist
|
|
|
|
with shallow copy operations:
|
|
|
|
|
1997-05-29 03:31:14 +08:00
|
|
|
a) recursive objects (compound objects that, directly or indirectly,
|
1995-02-10 01:18:10 +08:00
|
|
|
contain a reference to themselves) may cause a recursive loop
|
|
|
|
|
1997-05-29 03:31:14 +08:00
|
|
|
b) because deep copy copies *everything* it may copy too much, e.g.
|
1995-02-10 01:18:10 +08:00
|
|
|
administrative data structures that should be shared even between
|
|
|
|
copies
|
|
|
|
|
|
|
|
Python's deep copy operation avoids these problems by:
|
|
|
|
|
1997-05-29 03:31:14 +08:00
|
|
|
a) keeping a table of objects already copied during the current
|
|
|
|
copying pass
|
1995-02-10 01:18:10 +08:00
|
|
|
|
1997-05-29 03:31:14 +08:00
|
|
|
b) letting user-defined classes override the copying operation or the
|
1995-02-10 01:18:10 +08:00
|
|
|
set of components copied
|
|
|
|
|
|
|
|
This version does not copy types like module, class, function, method,
|
|
|
|
nor stack trace, stack frame, nor file, socket, window, nor array, nor
|
|
|
|
any similar types.
|
|
|
|
|
|
|
|
Classes can use the same interfaces to control copying that they use
|
|
|
|
to control pickling: they can define methods called __getinitargs__(),
|
1997-12-08 00:18:22 +08:00
|
|
|
__getstate__() and __setstate__(). See the documentation for module
|
1995-02-10 01:18:10 +08:00
|
|
|
"pickle" for information on these methods.
|
|
|
|
"""
|
1995-01-10 08:34:21 +08:00
|
|
|
|
|
|
|
import types
|
2008-05-11 16:55:36 +08:00
|
|
|
from copyreg import dispatch_table
|
1995-01-10 08:34:21 +08:00
|
|
|
|
2000-08-17 13:06:49 +08:00
|
|
|
class Error(Exception):
|
2001-01-15 07:36:06 +08:00
|
|
|
pass
|
|
|
|
error = Error # backward compatibility
|
1995-01-10 08:34:21 +08:00
|
|
|
|
2000-11-28 05:53:14 +08:00
|
|
|
try:
|
|
|
|
from org.python.core import PyStringMap
|
|
|
|
except ImportError:
|
|
|
|
PyStringMap = None
|
|
|
|
|
2003-02-07 03:53:22 +08:00
|
|
|
__all__ = ["Error", "copy", "deepcopy"]
|
2001-01-21 03:54:20 +08:00
|
|
|
|
1995-01-10 08:34:21 +08:00
|
|
|
def copy(x):
|
2001-01-15 07:36:06 +08:00
|
|
|
"""Shallow copy operation on arbitrary Python objects.
|
|
|
|
|
|
|
|
See the module's __doc__ string for more info.
|
|
|
|
"""
|
|
|
|
|
2003-02-08 01:30:18 +08:00
|
|
|
cls = type(x)
|
|
|
|
|
|
|
|
copier = _copy_dispatch.get(cls)
|
|
|
|
if copier:
|
|
|
|
return copier(x)
|
|
|
|
|
|
|
|
copier = getattr(cls, "__copy__", None)
|
|
|
|
if copier:
|
|
|
|
return copier(x)
|
|
|
|
|
|
|
|
reductor = dispatch_table.get(cls)
|
2003-02-19 09:19:28 +08:00
|
|
|
if reductor:
|
|
|
|
rv = reductor(x)
|
|
|
|
else:
|
|
|
|
reductor = getattr(x, "__reduce_ex__", None)
|
|
|
|
if reductor:
|
|
|
|
rv = reductor(2)
|
|
|
|
else:
|
|
|
|
reductor = getattr(x, "__reduce__", None)
|
|
|
|
if reductor:
|
|
|
|
rv = reductor()
|
|
|
|
else:
|
|
|
|
raise Error("un(shallow)copyable object of type %s" % cls)
|
|
|
|
|
|
|
|
return _reconstruct(x, rv, 0)
|
2003-02-19 10:35:07 +08:00
|
|
|
|
2003-02-07 03:53:22 +08:00
|
|
|
|
1995-01-10 08:34:21 +08:00
|
|
|
_copy_dispatch = d = {}
|
|
|
|
|
2004-03-08 13:59:33 +08:00
|
|
|
def _copy_immutable(x):
|
2001-01-15 07:36:06 +08:00
|
|
|
return x
|
2007-02-27 11:41:04 +08:00
|
|
|
for t in (type(None), int, float, bool, str, tuple,
|
2007-06-08 07:15:56 +08:00
|
|
|
frozenset, type, range,
|
Merged revisions 61834,61841-61842,61851-61853,61863-61864,61869-61870,61874,61889 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r61834 | raymond.hettinger | 2008-03-24 07:07:49 +0100 (Mon, 24 Mar 2008) | 1 line
Tighten documentation for Random.triangular.
........
r61841 | raymond.hettinger | 2008-03-24 09:17:39 +0100 (Mon, 24 Mar 2008) | 1 line
Issue 2460: Make Ellipsis objects copyable.
........
r61842 | georg.brandl | 2008-03-24 10:34:34 +0100 (Mon, 24 Mar 2008) | 2 lines
#1700821: add a note to audioop docs about signedness of sample formats.
........
r61851 | christian.heimes | 2008-03-24 20:57:42 +0100 (Mon, 24 Mar 2008) | 1 line
Added quick hack for bzr
........
r61852 | christian.heimes | 2008-03-24 20:58:17 +0100 (Mon, 24 Mar 2008) | 1 line
Added quick hack for bzr
........
r61853 | amaury.forgeotdarc | 2008-03-24 22:04:10 +0100 (Mon, 24 Mar 2008) | 4 lines
Issue2469: Correct a typo I introduced at r61793: compilation error with UCS4 builds.
All buildbots compile with UCS2...
........
r61863 | neal.norwitz | 2008-03-25 05:17:38 +0100 (Tue, 25 Mar 2008) | 2 lines
Fix a bunch of UnboundLocalErrors when the tests fail.
........
r61864 | neal.norwitz | 2008-03-25 05:18:18 +0100 (Tue, 25 Mar 2008) | 2 lines
Try to fix a bunch of compiler warnings on Win64.
........
r61869 | neal.norwitz | 2008-03-25 07:35:10 +0100 (Tue, 25 Mar 2008) | 3 lines
Don't try to close a non-open file.
Don't let file removal cause the test to fail.
........
r61870 | neal.norwitz | 2008-03-25 08:00:39 +0100 (Tue, 25 Mar 2008) | 7 lines
Try to get this test to be more stable:
* disable gc during the test run because we are spawning objects and there
was an exception when calling Popen.__del__
* Always set an alarm handler so the process doesn't exit if the test fails
(should probably add assertions on the value of hndl_called in more places)
* Using a negative time causes Linux to treat it as zero, so disable that test.
........
r61874 | gregory.p.smith | 2008-03-25 08:31:28 +0100 (Tue, 25 Mar 2008) | 2 lines
Use a 32-bit unsigned int here, a long is not needed.
........
r61889 | georg.brandl | 2008-03-25 12:59:51 +0100 (Tue, 25 Mar 2008) | 2 lines
Move declarations to block start.
........
2008-03-25 22:56:36 +08:00
|
|
|
types.BuiltinFunctionType, type(Ellipsis),
|
2006-02-26 12:21:50 +08:00
|
|
|
types.FunctionType):
|
2004-03-08 13:59:33 +08:00
|
|
|
d[t] = _copy_immutable
|
2007-06-08 07:15:56 +08:00
|
|
|
t = getattr(types, "CodeType", None)
|
|
|
|
if t is not None:
|
|
|
|
d[t] = _copy_immutable
|
|
|
|
for name in ("complex", "unicode"):
|
|
|
|
t = globals()['__builtins__'].get(name)
|
2004-03-08 13:59:33 +08:00
|
|
|
if t is not None:
|
|
|
|
d[t] = _copy_immutable
|
|
|
|
|
|
|
|
def _copy_with_constructor(x):
|
|
|
|
return type(x)(x)
|
|
|
|
for t in (list, dict, set):
|
|
|
|
d[t] = _copy_with_constructor
|
|
|
|
|
|
|
|
def _copy_with_copy_method(x):
|
2001-01-15 07:36:06 +08:00
|
|
|
return x.copy()
|
2000-11-28 05:53:14 +08:00
|
|
|
if PyStringMap is not None:
|
2004-03-08 13:59:33 +08:00
|
|
|
d[PyStringMap] = _copy_with_copy_method
|
1995-01-10 08:34:21 +08:00
|
|
|
|
|
|
|
del d
|
|
|
|
|
2003-02-08 01:30:18 +08:00
|
|
|
def deepcopy(x, memo=None, _nil=[]):
|
2001-01-15 07:36:06 +08:00
|
|
|
"""Deep copy operation on arbitrary Python objects.
|
|
|
|
|
|
|
|
See the module's __doc__ string for more info.
|
|
|
|
"""
|
|
|
|
|
|
|
|
if memo is None:
|
|
|
|
memo = {}
|
2003-02-08 01:30:18 +08:00
|
|
|
|
2001-01-15 07:36:06 +08:00
|
|
|
d = id(x)
|
2003-02-08 01:30:18 +08:00
|
|
|
y = memo.get(d, _nil)
|
|
|
|
if y is not _nil:
|
|
|
|
return y
|
|
|
|
|
|
|
|
cls = type(x)
|
|
|
|
|
|
|
|
copier = _deepcopy_dispatch.get(cls)
|
|
|
|
if copier:
|
|
|
|
y = copier(x, memo)
|
|
|
|
else:
|
2001-01-15 07:36:06 +08:00
|
|
|
try:
|
2003-02-08 01:30:18 +08:00
|
|
|
issc = issubclass(cls, type)
|
|
|
|
except TypeError: # cls is not a class (old Boost; see SF #502085)
|
2002-06-11 05:10:27 +08:00
|
|
|
issc = 0
|
|
|
|
if issc:
|
2003-02-19 09:19:28 +08:00
|
|
|
y = _deepcopy_atomic(x, memo)
|
2003-02-08 01:30:18 +08:00
|
|
|
else:
|
2003-02-19 09:19:28 +08:00
|
|
|
copier = getattr(x, "__deepcopy__", None)
|
|
|
|
if copier:
|
|
|
|
y = copier(memo)
|
|
|
|
else:
|
|
|
|
reductor = dispatch_table.get(cls)
|
|
|
|
if reductor:
|
|
|
|
rv = reductor(x)
|
|
|
|
else:
|
|
|
|
reductor = getattr(x, "__reduce_ex__", None)
|
|
|
|
if reductor:
|
|
|
|
rv = reductor(2)
|
|
|
|
else:
|
|
|
|
reductor = getattr(x, "__reduce__", None)
|
|
|
|
if reductor:
|
|
|
|
rv = reductor()
|
|
|
|
else:
|
|
|
|
raise Error(
|
|
|
|
"un(deep)copyable object of type %s" % cls)
|
|
|
|
y = _reconstruct(x, rv, 1, memo)
|
2003-02-08 01:30:18 +08:00
|
|
|
|
2001-01-15 07:36:06 +08:00
|
|
|
memo[d] = y
|
2002-08-13 04:20:08 +08:00
|
|
|
_keep_alive(x, memo) # Make sure x lives at least as long as d
|
2001-01-15 07:36:06 +08:00
|
|
|
return y
|
1995-01-10 08:34:21 +08:00
|
|
|
|
|
|
|
_deepcopy_dispatch = d = {}
|
|
|
|
|
|
|
|
def _deepcopy_atomic(x, memo):
|
2001-01-15 07:36:06 +08:00
|
|
|
return x
|
2005-02-07 22:16:21 +08:00
|
|
|
d[type(None)] = _deepcopy_atomic
|
Merged revisions 61834,61841-61842,61851-61853,61863-61864,61869-61870,61874,61889 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r61834 | raymond.hettinger | 2008-03-24 07:07:49 +0100 (Mon, 24 Mar 2008) | 1 line
Tighten documentation for Random.triangular.
........
r61841 | raymond.hettinger | 2008-03-24 09:17:39 +0100 (Mon, 24 Mar 2008) | 1 line
Issue 2460: Make Ellipsis objects copyable.
........
r61842 | georg.brandl | 2008-03-24 10:34:34 +0100 (Mon, 24 Mar 2008) | 2 lines
#1700821: add a note to audioop docs about signedness of sample formats.
........
r61851 | christian.heimes | 2008-03-24 20:57:42 +0100 (Mon, 24 Mar 2008) | 1 line
Added quick hack for bzr
........
r61852 | christian.heimes | 2008-03-24 20:58:17 +0100 (Mon, 24 Mar 2008) | 1 line
Added quick hack for bzr
........
r61853 | amaury.forgeotdarc | 2008-03-24 22:04:10 +0100 (Mon, 24 Mar 2008) | 4 lines
Issue2469: Correct a typo I introduced at r61793: compilation error with UCS4 builds.
All buildbots compile with UCS2...
........
r61863 | neal.norwitz | 2008-03-25 05:17:38 +0100 (Tue, 25 Mar 2008) | 2 lines
Fix a bunch of UnboundLocalErrors when the tests fail.
........
r61864 | neal.norwitz | 2008-03-25 05:18:18 +0100 (Tue, 25 Mar 2008) | 2 lines
Try to fix a bunch of compiler warnings on Win64.
........
r61869 | neal.norwitz | 2008-03-25 07:35:10 +0100 (Tue, 25 Mar 2008) | 3 lines
Don't try to close a non-open file.
Don't let file removal cause the test to fail.
........
r61870 | neal.norwitz | 2008-03-25 08:00:39 +0100 (Tue, 25 Mar 2008) | 7 lines
Try to get this test to be more stable:
* disable gc during the test run because we are spawning objects and there
was an exception when calling Popen.__del__
* Always set an alarm handler so the process doesn't exit if the test fails
(should probably add assertions on the value of hndl_called in more places)
* Using a negative time causes Linux to treat it as zero, so disable that test.
........
r61874 | gregory.p.smith | 2008-03-25 08:31:28 +0100 (Tue, 25 Mar 2008) | 2 lines
Use a 32-bit unsigned int here, a long is not needed.
........
r61889 | georg.brandl | 2008-03-25 12:59:51 +0100 (Tue, 25 Mar 2008) | 2 lines
Move declarations to block start.
........
2008-03-25 22:56:36 +08:00
|
|
|
d[type(Ellipsis)] = _deepcopy_atomic
|
2005-02-07 22:16:21 +08:00
|
|
|
d[int] = _deepcopy_atomic
|
|
|
|
d[float] = _deepcopy_atomic
|
|
|
|
d[bool] = _deepcopy_atomic
|
2001-09-29 02:16:13 +08:00
|
|
|
try:
|
2005-02-07 22:16:21 +08:00
|
|
|
d[complex] = _deepcopy_atomic
|
2005-03-08 23:03:08 +08:00
|
|
|
except NameError:
|
2001-09-29 02:16:13 +08:00
|
|
|
pass
|
2007-11-07 05:34:58 +08:00
|
|
|
d[bytes] = _deepcopy_atomic
|
2005-02-07 22:16:21 +08:00
|
|
|
d[str] = _deepcopy_atomic
|
2002-03-01 07:19:52 +08:00
|
|
|
try:
|
|
|
|
d[types.CodeType] = _deepcopy_atomic
|
|
|
|
except AttributeError:
|
|
|
|
pass
|
2005-02-07 22:16:21 +08:00
|
|
|
d[type] = _deepcopy_atomic
|
2007-05-08 06:24:25 +08:00
|
|
|
d[range] = _deepcopy_atomic
|
2003-06-14 15:10:06 +08:00
|
|
|
d[types.BuiltinFunctionType] = _deepcopy_atomic
|
2006-02-26 06:38:04 +08:00
|
|
|
d[types.FunctionType] = _deepcopy_atomic
|
1995-01-10 08:34:21 +08:00
|
|
|
|
|
|
|
def _deepcopy_list(x, memo):
|
2001-01-15 07:36:06 +08:00
|
|
|
y = []
|
|
|
|
memo[id(x)] = y
|
|
|
|
for a in x:
|
|
|
|
y.append(deepcopy(a, memo))
|
|
|
|
return y
|
2005-02-07 22:16:21 +08:00
|
|
|
d[list] = _deepcopy_list
|
1995-01-10 08:34:21 +08:00
|
|
|
|
|
|
|
def _deepcopy_tuple(x, memo):
|
2001-01-15 07:36:06 +08:00
|
|
|
y = []
|
|
|
|
for a in x:
|
|
|
|
y.append(deepcopy(a, memo))
|
|
|
|
d = id(x)
|
|
|
|
try:
|
|
|
|
return memo[d]
|
|
|
|
except KeyError:
|
|
|
|
pass
|
|
|
|
for i in range(len(x)):
|
|
|
|
if x[i] is not y[i]:
|
|
|
|
y = tuple(y)
|
|
|
|
break
|
|
|
|
else:
|
|
|
|
y = x
|
|
|
|
memo[d] = y
|
|
|
|
return y
|
2005-02-07 22:16:21 +08:00
|
|
|
d[tuple] = _deepcopy_tuple
|
1995-01-10 08:34:21 +08:00
|
|
|
|
|
|
|
def _deepcopy_dict(x, memo):
|
2001-01-15 07:36:06 +08:00
|
|
|
y = {}
|
|
|
|
memo[id(x)] = y
|
2007-02-11 14:12:03 +08:00
|
|
|
for key, value in x.items():
|
2002-06-03 02:55:56 +08:00
|
|
|
y[deepcopy(key, memo)] = deepcopy(value, memo)
|
2001-01-15 07:36:06 +08:00
|
|
|
return y
|
2005-02-07 22:16:21 +08:00
|
|
|
d[dict] = _deepcopy_dict
|
2000-11-28 05:53:14 +08:00
|
|
|
if PyStringMap is not None:
|
|
|
|
d[PyStringMap] = _deepcopy_dict
|
1995-01-10 08:34:21 +08:00
|
|
|
|
1997-08-21 06:26:19 +08:00
|
|
|
def _keep_alive(x, memo):
|
2001-01-15 07:36:06 +08:00
|
|
|
"""Keeps a reference to the object x in the memo.
|
|
|
|
|
|
|
|
Because we remember objects by their id, we have
|
|
|
|
to assure that possibly temporary objects are kept
|
|
|
|
alive by referencing them.
|
|
|
|
We store a reference at the id of the memo, which should
|
|
|
|
normally not be used unless someone tries to deepcopy
|
|
|
|
the memo itself...
|
|
|
|
"""
|
|
|
|
try:
|
|
|
|
memo[id(memo)].append(x)
|
|
|
|
except KeyError:
|
|
|
|
# aha, this is the first one :-)
|
|
|
|
memo[id(memo)]=[x]
|
1997-08-21 06:26:19 +08:00
|
|
|
|
2001-12-29 05:33:22 +08:00
|
|
|
def _reconstruct(x, info, deep, memo=None):
|
2001-09-29 02:13:29 +08:00
|
|
|
if isinstance(info, str):
|
|
|
|
return x
|
|
|
|
assert isinstance(info, tuple)
|
2001-12-29 05:33:22 +08:00
|
|
|
if memo is None:
|
|
|
|
memo = {}
|
2001-09-29 02:13:29 +08:00
|
|
|
n = len(info)
|
2003-02-07 02:18:23 +08:00
|
|
|
assert n in (2, 3, 4, 5)
|
2001-09-29 02:13:29 +08:00
|
|
|
callable, args = info[:2]
|
|
|
|
if n > 2:
|
|
|
|
state = info[2]
|
|
|
|
else:
|
|
|
|
state = {}
|
2003-02-07 02:18:23 +08:00
|
|
|
if n > 3:
|
|
|
|
listiter = info[3]
|
|
|
|
else:
|
|
|
|
listiter = None
|
|
|
|
if n > 4:
|
|
|
|
dictiter = info[4]
|
|
|
|
else:
|
|
|
|
dictiter = None
|
2001-09-29 02:13:29 +08:00
|
|
|
if deep:
|
2001-12-29 05:33:22 +08:00
|
|
|
args = deepcopy(args, memo)
|
2001-09-29 02:13:29 +08:00
|
|
|
y = callable(*args)
|
2003-06-14 03:28:47 +08:00
|
|
|
memo[id(x)] = y
|
2003-02-07 02:18:23 +08:00
|
|
|
if listiter is not None:
|
|
|
|
for item in listiter:
|
|
|
|
if deep:
|
|
|
|
item = deepcopy(item, memo)
|
|
|
|
y.append(item)
|
|
|
|
if dictiter is not None:
|
|
|
|
for key, value in dictiter:
|
|
|
|
if deep:
|
|
|
|
key = deepcopy(key, memo)
|
|
|
|
value = deepcopy(value, memo)
|
|
|
|
y[key] = value
|
2001-09-29 02:13:29 +08:00
|
|
|
if state:
|
|
|
|
if deep:
|
2001-12-29 05:33:22 +08:00
|
|
|
state = deepcopy(state, memo)
|
2002-06-07 01:41:20 +08:00
|
|
|
if hasattr(y, '__setstate__'):
|
|
|
|
y.__setstate__(state)
|
|
|
|
else:
|
2003-02-07 03:53:22 +08:00
|
|
|
if isinstance(state, tuple) and len(state) == 2:
|
|
|
|
state, slotstate = state
|
|
|
|
else:
|
|
|
|
slotstate = None
|
|
|
|
if state is not None:
|
|
|
|
y.__dict__.update(state)
|
|
|
|
if slotstate is not None:
|
2007-02-11 14:12:03 +08:00
|
|
|
for key, value in slotstate.items():
|
2003-02-07 03:53:22 +08:00
|
|
|
setattr(y, key, value)
|
2001-09-29 02:13:29 +08:00
|
|
|
return y
|
|
|
|
|
1995-01-10 08:34:21 +08:00
|
|
|
del d
|
|
|
|
|
|
|
|
del types
|
|
|
|
|
1997-12-08 00:18:22 +08:00
|
|
|
# Helper for instance creation without calling __init__
|
|
|
|
class _EmptyClass:
|
|
|
|
pass
|
|
|
|
|
1995-01-10 08:34:21 +08:00
|
|
|
def _test():
|
2007-01-16 00:59:06 +08:00
|
|
|
l = [None, 1, 2, 3.14, 'xyzzy', (1, 2), [3.14, 'abc'],
|
2001-01-15 07:36:06 +08:00
|
|
|
{'abc': 'ABC'}, (), [], {}]
|
|
|
|
l1 = copy(l)
|
2007-02-09 13:37:30 +08:00
|
|
|
print(l1==l)
|
2001-01-15 07:36:06 +08:00
|
|
|
l1 = map(copy, l)
|
2007-02-09 13:37:30 +08:00
|
|
|
print(l1==l)
|
2001-01-15 07:36:06 +08:00
|
|
|
l1 = deepcopy(l)
|
2007-02-09 13:37:30 +08:00
|
|
|
print(l1==l)
|
2001-01-15 07:36:06 +08:00
|
|
|
class C:
|
|
|
|
def __init__(self, arg=None):
|
|
|
|
self.a = 1
|
|
|
|
self.arg = arg
|
|
|
|
if __name__ == '__main__':
|
|
|
|
import sys
|
|
|
|
file = sys.argv[0]
|
|
|
|
else:
|
|
|
|
file = __file__
|
|
|
|
self.fp = open(file)
|
|
|
|
self.fp.close()
|
|
|
|
def __getstate__(self):
|
|
|
|
return {'a': self.a, 'arg': self.arg}
|
|
|
|
def __setstate__(self, state):
|
2007-02-11 14:12:03 +08:00
|
|
|
for key, value in state.items():
|
2002-06-03 02:55:56 +08:00
|
|
|
setattr(self, key, value)
|
2003-02-08 01:30:18 +08:00
|
|
|
def __deepcopy__(self, memo=None):
|
2001-01-15 07:36:06 +08:00
|
|
|
new = self.__class__(deepcopy(self.arg, memo))
|
|
|
|
new.a = self.a
|
|
|
|
return new
|
|
|
|
c = C('argument sketch')
|
|
|
|
l.append(c)
|
|
|
|
l2 = copy(l)
|
2007-02-09 13:37:30 +08:00
|
|
|
print(l == l2)
|
|
|
|
print(l)
|
|
|
|
print(l2)
|
2001-01-15 07:36:06 +08:00
|
|
|
l2 = deepcopy(l)
|
2007-02-09 13:37:30 +08:00
|
|
|
print(l == l2)
|
|
|
|
print(l)
|
|
|
|
print(l2)
|
2001-01-15 07:36:06 +08:00
|
|
|
l.append({l[1]: l, 'xyz': l[2]})
|
|
|
|
l3 = copy(l)
|
2008-05-16 15:12:44 +08:00
|
|
|
import reprlib
|
|
|
|
print(map(reprlib.repr, l))
|
|
|
|
print(map(reprlib.repr, l1))
|
|
|
|
print(map(reprlib.repr, l2))
|
|
|
|
print(map(reprlib.repr, l3))
|
2001-01-15 07:36:06 +08:00
|
|
|
l3 = deepcopy(l)
|
2008-05-16 15:12:44 +08:00
|
|
|
print(map(reprlib.repr, l))
|
|
|
|
print(map(reprlib.repr, l1))
|
|
|
|
print(map(reprlib.repr, l2))
|
|
|
|
print(map(reprlib.repr, l3))
|
1995-01-10 08:34:21 +08:00
|
|
|
|
|
|
|
if __name__ == '__main__':
|
2001-01-15 07:36:06 +08:00
|
|
|
_test()
|