diff options
Diffstat (limited to 'Lib/copy.py')
| -rw-r--r-- | Lib/copy.py | 366 |
1 files changed, 183 insertions, 183 deletions
diff --git a/Lib/copy.py b/Lib/copy.py index fc2e1ff..cdd2fdf 100644 --- a/Lib/copy.py +++ b/Lib/copy.py @@ -2,10 +2,10 @@ Interface summary: - import copy + import copy - x = copy.copy(y) # make a shallow copy of y - x = copy.deepcopy(y) # make a deep copy of y + x = copy.copy(y) # make a shallow copy of y + x = copy.deepcopy(y) # make a deep copy of y For module specific errors, copy.error is raised. @@ -53,8 +53,8 @@ __getstate__() and __setstate__(). See the documentation for module import types class Error(Exception): - pass -error = Error # backward compatibility + pass +error = Error # backward compatibility try: from org.python.core import PyStringMap @@ -62,28 +62,28 @@ except ImportError: PyStringMap = None def copy(x): - """Shallow copy operation on arbitrary Python objects. - - See the module's __doc__ string for more info. - """ - - try: - copierfunction = _copy_dispatch[type(x)] - except KeyError: - try: - copier = x.__copy__ - except AttributeError: - raise error, \ - "un(shallow)copyable object of type %s" % type(x) - y = copier() - else: - y = copierfunction(x) - return y + """Shallow copy operation on arbitrary Python objects. + + See the module's __doc__ string for more info. + """ + + try: + copierfunction = _copy_dispatch[type(x)] + except KeyError: + try: + copier = x.__copy__ + except AttributeError: + raise error, \ + "un(shallow)copyable object of type %s" % type(x) + y = copier() + else: + y = copierfunction(x) + return y _copy_dispatch = d = {} def _copy_atomic(x): - return x + return x d[types.NoneType] = _copy_atomic d[types.IntType] = _copy_atomic d[types.LongType] = _copy_atomic @@ -91,78 +91,78 @@ d[types.FloatType] = _copy_atomic d[types.StringType] = _copy_atomic d[types.UnicodeType] = _copy_atomic try: - d[types.CodeType] = _copy_atomic + d[types.CodeType] = _copy_atomic except AttributeError: - pass + pass d[types.TypeType] = _copy_atomic d[types.XRangeType] = _copy_atomic d[types.ClassType] = _copy_atomic def _copy_list(x): - return x[:] + return x[:] d[types.ListType] = _copy_list def _copy_tuple(x): - return x[:] + return x[:] d[types.TupleType] = _copy_tuple def _copy_dict(x): - return x.copy() + return x.copy() d[types.DictionaryType] = _copy_dict if PyStringMap is not None: d[PyStringMap] = _copy_dict def _copy_inst(x): - if hasattr(x, '__copy__'): - return x.__copy__() - if hasattr(x, '__getinitargs__'): - args = x.__getinitargs__() - y = apply(x.__class__, args) - else: - y = _EmptyClass() - y.__class__ = x.__class__ - if hasattr(x, '__getstate__'): - state = x.__getstate__() - else: - state = x.__dict__ - if hasattr(y, '__setstate__'): - y.__setstate__(state) - else: - y.__dict__.update(state) - return y + if hasattr(x, '__copy__'): + return x.__copy__() + if hasattr(x, '__getinitargs__'): + args = x.__getinitargs__() + y = apply(x.__class__, args) + else: + y = _EmptyClass() + y.__class__ = x.__class__ + if hasattr(x, '__getstate__'): + state = x.__getstate__() + else: + state = x.__dict__ + if hasattr(y, '__setstate__'): + y.__setstate__(state) + else: + y.__dict__.update(state) + return y d[types.InstanceType] = _copy_inst del d def deepcopy(x, memo = None): - """Deep copy operation on arbitrary Python objects. - - See the module's __doc__ string for more info. - """ - - if memo is None: - memo = {} - d = id(x) - if memo.has_key(d): - return memo[d] - try: - copierfunction = _deepcopy_dispatch[type(x)] - except KeyError: - try: - copier = x.__deepcopy__ - except AttributeError: - raise error, \ - "un-deep-copyable object of type %s" % type(x) - y = copier(memo) - else: - y = copierfunction(x, memo) - memo[d] = y - return y + """Deep copy operation on arbitrary Python objects. + + See the module's __doc__ string for more info. + """ + + if memo is None: + memo = {} + d = id(x) + if memo.has_key(d): + return memo[d] + try: + copierfunction = _deepcopy_dispatch[type(x)] + except KeyError: + try: + copier = x.__deepcopy__ + except AttributeError: + raise error, \ + "un-deep-copyable object of type %s" % type(x) + y = copier(memo) + else: + y = copierfunction(x, memo) + memo[d] = y + return y _deepcopy_dispatch = d = {} def _deepcopy_atomic(x, memo): - return x + return x d[types.NoneType] = _deepcopy_atomic d[types.IntType] = _deepcopy_atomic d[types.LongType] = _deepcopy_atomic @@ -174,81 +174,81 @@ d[types.TypeType] = _deepcopy_atomic d[types.XRangeType] = _deepcopy_atomic def _deepcopy_list(x, memo): - y = [] - memo[id(x)] = y - for a in x: - y.append(deepcopy(a, memo)) - return y + y = [] + memo[id(x)] = y + for a in x: + y.append(deepcopy(a, memo)) + return y d[types.ListType] = _deepcopy_list def _deepcopy_tuple(x, memo): - 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 + 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 d[types.TupleType] = _deepcopy_tuple def _deepcopy_dict(x, memo): - y = {} - memo[id(x)] = y - for key in x.keys(): - y[deepcopy(key, memo)] = deepcopy(x[key], memo) - return y + y = {} + memo[id(x)] = y + for key in x.keys(): + y[deepcopy(key, memo)] = deepcopy(x[key], memo) + return y d[types.DictionaryType] = _deepcopy_dict if PyStringMap is not None: d[PyStringMap] = _deepcopy_dict def _keep_alive(x, memo): - """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] + """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] def _deepcopy_inst(x, memo): - if hasattr(x, '__deepcopy__'): - return x.__deepcopy__(memo) - if hasattr(x, '__getinitargs__'): - args = x.__getinitargs__() - _keep_alive(args, memo) - args = deepcopy(args, memo) - y = apply(x.__class__, args) - else: - y = _EmptyClass() - y.__class__ = x.__class__ - memo[id(x)] = y - if hasattr(x, '__getstate__'): - state = x.__getstate__() - _keep_alive(state, memo) - else: - state = x.__dict__ - state = deepcopy(state, memo) - if hasattr(y, '__setstate__'): - y.__setstate__(state) - else: - y.__dict__.update(state) - return y + if hasattr(x, '__deepcopy__'): + return x.__deepcopy__(memo) + if hasattr(x, '__getinitargs__'): + args = x.__getinitargs__() + _keep_alive(args, memo) + args = deepcopy(args, memo) + y = apply(x.__class__, args) + else: + y = _EmptyClass() + y.__class__ = x.__class__ + memo[id(x)] = y + if hasattr(x, '__getstate__'): + state = x.__getstate__() + _keep_alive(state, memo) + else: + state = x.__dict__ + state = deepcopy(state, memo) + if hasattr(y, '__setstate__'): + y.__setstate__(state) + else: + y.__dict__.update(state) + return y d[types.InstanceType] = _deepcopy_inst del d @@ -260,57 +260,57 @@ class _EmptyClass: pass def _test(): - l = [None, 1, 2L, 3.14, 'xyzzy', (1, 2L), [3.14, 'abc'], - {'abc': 'ABC'}, (), [], {}] - l1 = copy(l) - print l1==l - l1 = map(copy, l) - print l1==l - l1 = deepcopy(l) - print l1==l - 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): - for key in state.keys(): - setattr(self, key, state[key]) - def __deepcopy__(self, memo = None): - new = self.__class__(deepcopy(self.arg, memo)) - new.a = self.a - return new - c = C('argument sketch') - l.append(c) - l2 = copy(l) - print l == l2 - print l - print l2 - l2 = deepcopy(l) - print l == l2 - print l - print l2 - l.append({l[1]: l, 'xyz': l[2]}) - l3 = copy(l) - import repr - print map(repr.repr, l) - print map(repr.repr, l1) - print map(repr.repr, l2) - print map(repr.repr, l3) - l3 = deepcopy(l) - import repr - print map(repr.repr, l) - print map(repr.repr, l1) - print map(repr.repr, l2) - print map(repr.repr, l3) + l = [None, 1, 2L, 3.14, 'xyzzy', (1, 2L), [3.14, 'abc'], + {'abc': 'ABC'}, (), [], {}] + l1 = copy(l) + print l1==l + l1 = map(copy, l) + print l1==l + l1 = deepcopy(l) + print l1==l + 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): + for key in state.keys(): + setattr(self, key, state[key]) + def __deepcopy__(self, memo = None): + new = self.__class__(deepcopy(self.arg, memo)) + new.a = self.a + return new + c = C('argument sketch') + l.append(c) + l2 = copy(l) + print l == l2 + print l + print l2 + l2 = deepcopy(l) + print l == l2 + print l + print l2 + l.append({l[1]: l, 'xyz': l[2]}) + l3 = copy(l) + import repr + print map(repr.repr, l) + print map(repr.repr, l1) + print map(repr.repr, l2) + print map(repr.repr, l3) + l3 = deepcopy(l) + import repr + print map(repr.repr, l) + print map(repr.repr, l1) + print map(repr.repr, l2) + print map(repr.repr, l3) if __name__ == '__main__': - _test() + _test() |