Guido van Rossum | 4b8c6ea | 2000-02-04 15:39:30 +0000 | [diff] [blame] | 1 | """Generic (shallow and deep) copying operations. |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 2 | |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 3 | Interface summary: |
| 4 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 5 | import copy |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 6 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 7 | x = copy.copy(y) # make a shallow copy of y |
| 8 | x = copy.deepcopy(y) # make a deep copy of y |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 9 | |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 10 | For module specific errors, copy.Error is raised. |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 11 | |
| 12 | The difference between shallow and deep copying is only relevant for |
| 13 | compound objects (objects that contain other objects, like lists or |
| 14 | class instances). |
| 15 | |
| 16 | - A shallow copy constructs a new compound object and then (to the |
| 17 | extent possible) inserts *the same objects* into in that the |
| 18 | original contains. |
| 19 | |
| 20 | - A deep copy constructs a new compound object and then, recursively, |
| 21 | inserts *copies* into it of the objects found in the original. |
| 22 | |
| 23 | Two problems often exist with deep copy operations that don't exist |
| 24 | with shallow copy operations: |
| 25 | |
Guido van Rossum | f7cea10 | 1997-05-28 19:31:14 +0000 | [diff] [blame] | 26 | a) recursive objects (compound objects that, directly or indirectly, |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 27 | contain a reference to themselves) may cause a recursive loop |
| 28 | |
Guido van Rossum | f7cea10 | 1997-05-28 19:31:14 +0000 | [diff] [blame] | 29 | b) because deep copy copies *everything* it may copy too much, e.g. |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 30 | administrative data structures that should be shared even between |
| 31 | copies |
| 32 | |
| 33 | Python's deep copy operation avoids these problems by: |
| 34 | |
Guido van Rossum | f7cea10 | 1997-05-28 19:31:14 +0000 | [diff] [blame] | 35 | a) keeping a table of objects already copied during the current |
| 36 | copying pass |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 37 | |
Guido van Rossum | f7cea10 | 1997-05-28 19:31:14 +0000 | [diff] [blame] | 38 | b) letting user-defined classes override the copying operation or the |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 39 | set of components copied |
| 40 | |
| 41 | This version does not copy types like module, class, function, method, |
| 42 | nor stack trace, stack frame, nor file, socket, window, nor array, nor |
| 43 | any similar types. |
| 44 | |
| 45 | Classes can use the same interfaces to control copying that they use |
| 46 | to control pickling: they can define methods called __getinitargs__(), |
Guido van Rossum | c5d2d51 | 1997-12-07 16:18:22 +0000 | [diff] [blame] | 47 | __getstate__() and __setstate__(). See the documentation for module |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 48 | "pickle" for information on these methods. |
| 49 | """ |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 50 | |
| 51 | import types |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 52 | from copy_reg import _better_reduce, dispatch_table |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 53 | |
Fred Drake | 227b120 | 2000-08-17 05:06:49 +0000 | [diff] [blame] | 54 | class Error(Exception): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 55 | pass |
| 56 | error = Error # backward compatibility |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 57 | |
Guido van Rossum | f8baad0 | 2000-11-27 21:53:14 +0000 | [diff] [blame] | 58 | try: |
| 59 | from org.python.core import PyStringMap |
| 60 | except ImportError: |
| 61 | PyStringMap = None |
| 62 | |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 63 | __all__ = ["Error", "copy", "deepcopy"] |
Skip Montanaro | e99d5ea | 2001-01-20 19:54:20 +0000 | [diff] [blame] | 64 | |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 65 | def copy(x): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 66 | """Shallow copy operation on arbitrary Python objects. |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 67 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 68 | See the module's __doc__ string for more info. |
| 69 | """ |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 70 | |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 71 | cls = type(x) |
| 72 | |
| 73 | copier = _copy_dispatch.get(cls) |
| 74 | if copier: |
| 75 | return copier(x) |
| 76 | |
| 77 | copier = getattr(cls, "__copy__", None) |
| 78 | if copier: |
| 79 | return copier(x) |
| 80 | |
| 81 | reductor = dispatch_table.get(cls) |
| 82 | if not reductor: |
| 83 | reductor = getattr(cls, "__reduce__", None) |
| 84 | if reductor == object.__reduce__: |
| 85 | reductor = _better_reduce |
| 86 | elif not reductor: |
| 87 | raise Error("un(shallow)copyable object of type %s" % cls) |
| 88 | |
| 89 | return _reconstruct(x, reductor(x), 0) |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 90 | |
| 91 | |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 92 | _copy_dispatch = d = {} |
| 93 | |
| 94 | def _copy_atomic(x): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 95 | return x |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 96 | d[types.NoneType] = _copy_atomic |
| 97 | d[types.IntType] = _copy_atomic |
| 98 | d[types.LongType] = _copy_atomic |
| 99 | d[types.FloatType] = _copy_atomic |
Martin v. Löwis | 71b7556 | 2003-01-16 10:40:00 +0000 | [diff] [blame] | 100 | d[types.BooleanType] = _copy_atomic |
Guido van Rossum | 8b9def3 | 2001-09-28 18:16:13 +0000 | [diff] [blame] | 101 | try: |
| 102 | d[types.ComplexType] = _copy_atomic |
| 103 | except AttributeError: |
| 104 | pass |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 105 | d[types.StringType] = _copy_atomic |
Martin v. Löwis | 339d0f7 | 2001-08-17 18:39:25 +0000 | [diff] [blame] | 106 | try: |
| 107 | d[types.UnicodeType] = _copy_atomic |
| 108 | except AttributeError: |
| 109 | pass |
Guido van Rossum | 2fff84d | 1999-01-25 21:37:02 +0000 | [diff] [blame] | 110 | try: |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 111 | d[types.CodeType] = _copy_atomic |
Guido van Rossum | 2fff84d | 1999-01-25 21:37:02 +0000 | [diff] [blame] | 112 | except AttributeError: |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 113 | pass |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 114 | d[types.TypeType] = _copy_atomic |
| 115 | d[types.XRangeType] = _copy_atomic |
Guido van Rossum | 55d2f39 | 1995-03-14 17:41:36 +0000 | [diff] [blame] | 116 | d[types.ClassType] = _copy_atomic |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 117 | |
| 118 | def _copy_list(x): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 119 | return x[:] |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 120 | d[types.ListType] = _copy_list |
| 121 | |
| 122 | def _copy_tuple(x): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 123 | return x[:] |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 124 | d[types.TupleType] = _copy_tuple |
| 125 | |
| 126 | def _copy_dict(x): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 127 | return x.copy() |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 128 | d[types.DictionaryType] = _copy_dict |
Guido van Rossum | f8baad0 | 2000-11-27 21:53:14 +0000 | [diff] [blame] | 129 | if PyStringMap is not None: |
| 130 | d[PyStringMap] = _copy_dict |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 131 | |
| 132 | def _copy_inst(x): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 133 | if hasattr(x, '__copy__'): |
| 134 | return x.__copy__() |
| 135 | if hasattr(x, '__getinitargs__'): |
| 136 | args = x.__getinitargs__() |
| 137 | y = apply(x.__class__, args) |
| 138 | else: |
| 139 | y = _EmptyClass() |
| 140 | y.__class__ = x.__class__ |
| 141 | if hasattr(x, '__getstate__'): |
| 142 | state = x.__getstate__() |
| 143 | else: |
| 144 | state = x.__dict__ |
| 145 | if hasattr(y, '__setstate__'): |
| 146 | y.__setstate__(state) |
| 147 | else: |
| 148 | y.__dict__.update(state) |
| 149 | return y |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 150 | d[types.InstanceType] = _copy_inst |
| 151 | |
| 152 | del d |
| 153 | |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 154 | def deepcopy(x, memo=None, _nil=[]): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 155 | """Deep copy operation on arbitrary Python objects. |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 156 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 157 | See the module's __doc__ string for more info. |
| 158 | """ |
Guido van Rossum | cc6764c | 1995-02-09 17:18:10 +0000 | [diff] [blame] | 159 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 160 | if memo is None: |
| 161 | memo = {} |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 162 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 163 | d = id(x) |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 164 | y = memo.get(d, _nil) |
| 165 | if y is not _nil: |
| 166 | return y |
| 167 | |
| 168 | cls = type(x) |
| 169 | |
| 170 | copier = _deepcopy_dispatch.get(cls) |
| 171 | if copier: |
| 172 | y = copier(x, memo) |
| 173 | else: |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 174 | try: |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 175 | issc = issubclass(cls, type) |
| 176 | except TypeError: # cls is not a class (old Boost; see SF #502085) |
Guido van Rossum | 11ade1d | 2002-06-10 21:10:27 +0000 | [diff] [blame] | 177 | issc = 0 |
| 178 | if issc: |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 179 | copier = _deepcopy_atomic |
Guido van Rossum | 6cef6d5 | 2001-09-28 18:13:29 +0000 | [diff] [blame] | 180 | else: |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 181 | copier = getattr(cls, "__deepcopy__", None) |
| 182 | |
| 183 | if copier: |
| 184 | y = copier(x, memo) |
| 185 | else: |
| 186 | reductor = dispatch_table.get(cls) |
| 187 | if not reductor: |
| 188 | reductor = getattr(cls, "__reduce__", None) |
| 189 | if reductor == object.__reduce__: |
| 190 | reductor = _better_reduce |
| 191 | elif not reductor: |
| 192 | raise Error("un(deep)copyable object of type %s" % cls) |
| 193 | y = _reconstruct(x, reductor(x), 1, memo) |
| 194 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 195 | memo[d] = y |
Guido van Rossum | 6115460 | 2002-08-12 20:20:08 +0000 | [diff] [blame] | 196 | _keep_alive(x, memo) # Make sure x lives at least as long as d |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 197 | return y |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 198 | |
| 199 | _deepcopy_dispatch = d = {} |
| 200 | |
| 201 | def _deepcopy_atomic(x, memo): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 202 | return x |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 203 | d[types.NoneType] = _deepcopy_atomic |
| 204 | d[types.IntType] = _deepcopy_atomic |
| 205 | d[types.LongType] = _deepcopy_atomic |
| 206 | d[types.FloatType] = _deepcopy_atomic |
Martin v. Löwis | 71b7556 | 2003-01-16 10:40:00 +0000 | [diff] [blame] | 207 | d[types.BooleanType] = _deepcopy_atomic |
Guido van Rossum | 8b9def3 | 2001-09-28 18:16:13 +0000 | [diff] [blame] | 208 | try: |
| 209 | d[types.ComplexType] = _deepcopy_atomic |
| 210 | except AttributeError: |
| 211 | pass |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 212 | d[types.StringType] = _deepcopy_atomic |
Martin v. Löwis | 339d0f7 | 2001-08-17 18:39:25 +0000 | [diff] [blame] | 213 | try: |
| 214 | d[types.UnicodeType] = _deepcopy_atomic |
| 215 | except AttributeError: |
| 216 | pass |
Guido van Rossum | 88b666c | 2002-02-28 23:19:52 +0000 | [diff] [blame] | 217 | try: |
| 218 | d[types.CodeType] = _deepcopy_atomic |
| 219 | except AttributeError: |
| 220 | pass |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 221 | d[types.TypeType] = _deepcopy_atomic |
| 222 | d[types.XRangeType] = _deepcopy_atomic |
Guido van Rossum | 1dca482 | 2003-02-07 17:53:23 +0000 | [diff] [blame] | 223 | d[types.ClassType] = _deepcopy_atomic |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 224 | |
| 225 | def _deepcopy_list(x, memo): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 226 | y = [] |
| 227 | memo[id(x)] = y |
| 228 | for a in x: |
| 229 | y.append(deepcopy(a, memo)) |
| 230 | return y |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 231 | d[types.ListType] = _deepcopy_list |
| 232 | |
| 233 | def _deepcopy_tuple(x, memo): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 234 | y = [] |
| 235 | for a in x: |
| 236 | y.append(deepcopy(a, memo)) |
| 237 | d = id(x) |
| 238 | try: |
| 239 | return memo[d] |
| 240 | except KeyError: |
| 241 | pass |
| 242 | for i in range(len(x)): |
| 243 | if x[i] is not y[i]: |
| 244 | y = tuple(y) |
| 245 | break |
| 246 | else: |
| 247 | y = x |
| 248 | memo[d] = y |
| 249 | return y |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 250 | d[types.TupleType] = _deepcopy_tuple |
| 251 | |
| 252 | def _deepcopy_dict(x, memo): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 253 | y = {} |
| 254 | memo[id(x)] = y |
Raymond Hettinger | e0d4972 | 2002-06-02 18:55:56 +0000 | [diff] [blame] | 255 | for key, value in x.iteritems(): |
| 256 | y[deepcopy(key, memo)] = deepcopy(value, memo) |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 257 | return y |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 258 | d[types.DictionaryType] = _deepcopy_dict |
Guido van Rossum | f8baad0 | 2000-11-27 21:53:14 +0000 | [diff] [blame] | 259 | if PyStringMap is not None: |
| 260 | d[PyStringMap] = _deepcopy_dict |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 261 | |
Guido van Rossum | 558be28 | 1997-08-20 22:26:19 +0000 | [diff] [blame] | 262 | def _keep_alive(x, memo): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 263 | """Keeps a reference to the object x in the memo. |
Guido van Rossum | 558be28 | 1997-08-20 22:26:19 +0000 | [diff] [blame] | 264 | |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 265 | Because we remember objects by their id, we have |
| 266 | to assure that possibly temporary objects are kept |
| 267 | alive by referencing them. |
| 268 | We store a reference at the id of the memo, which should |
| 269 | normally not be used unless someone tries to deepcopy |
| 270 | the memo itself... |
| 271 | """ |
| 272 | try: |
| 273 | memo[id(memo)].append(x) |
| 274 | except KeyError: |
| 275 | # aha, this is the first one :-) |
| 276 | memo[id(memo)]=[x] |
Guido van Rossum | 558be28 | 1997-08-20 22:26:19 +0000 | [diff] [blame] | 277 | |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 278 | def _deepcopy_inst(x, memo): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 279 | if hasattr(x, '__deepcopy__'): |
| 280 | return x.__deepcopy__(memo) |
| 281 | if hasattr(x, '__getinitargs__'): |
| 282 | args = x.__getinitargs__() |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 283 | args = deepcopy(args, memo) |
| 284 | y = apply(x.__class__, args) |
| 285 | else: |
| 286 | y = _EmptyClass() |
| 287 | y.__class__ = x.__class__ |
| 288 | memo[id(x)] = y |
| 289 | if hasattr(x, '__getstate__'): |
| 290 | state = x.__getstate__() |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 291 | else: |
| 292 | state = x.__dict__ |
| 293 | state = deepcopy(state, memo) |
| 294 | if hasattr(y, '__setstate__'): |
| 295 | y.__setstate__(state) |
| 296 | else: |
| 297 | y.__dict__.update(state) |
| 298 | return y |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 299 | d[types.InstanceType] = _deepcopy_inst |
| 300 | |
Guido van Rossum | 1e91c14 | 2001-12-28 21:33:22 +0000 | [diff] [blame] | 301 | def _reconstruct(x, info, deep, memo=None): |
Guido van Rossum | 6cef6d5 | 2001-09-28 18:13:29 +0000 | [diff] [blame] | 302 | if isinstance(info, str): |
| 303 | return x |
| 304 | assert isinstance(info, tuple) |
Guido van Rossum | 1e91c14 | 2001-12-28 21:33:22 +0000 | [diff] [blame] | 305 | if memo is None: |
| 306 | memo = {} |
Guido van Rossum | 6cef6d5 | 2001-09-28 18:13:29 +0000 | [diff] [blame] | 307 | n = len(info) |
Guido van Rossum | 90e05b0 | 2003-02-06 18:18:23 +0000 | [diff] [blame] | 308 | assert n in (2, 3, 4, 5) |
Guido van Rossum | 6cef6d5 | 2001-09-28 18:13:29 +0000 | [diff] [blame] | 309 | callable, args = info[:2] |
| 310 | if n > 2: |
| 311 | state = info[2] |
| 312 | else: |
| 313 | state = {} |
Guido van Rossum | 90e05b0 | 2003-02-06 18:18:23 +0000 | [diff] [blame] | 314 | if n > 3: |
| 315 | listiter = info[3] |
| 316 | else: |
| 317 | listiter = None |
| 318 | if n > 4: |
| 319 | dictiter = info[4] |
| 320 | else: |
| 321 | dictiter = None |
Guido van Rossum | 6cef6d5 | 2001-09-28 18:13:29 +0000 | [diff] [blame] | 322 | if deep: |
Guido van Rossum | 1e91c14 | 2001-12-28 21:33:22 +0000 | [diff] [blame] | 323 | args = deepcopy(args, memo) |
Guido van Rossum | 6cef6d5 | 2001-09-28 18:13:29 +0000 | [diff] [blame] | 324 | y = callable(*args) |
Guido van Rossum | 90e05b0 | 2003-02-06 18:18:23 +0000 | [diff] [blame] | 325 | if listiter is not None: |
| 326 | for item in listiter: |
| 327 | if deep: |
| 328 | item = deepcopy(item, memo) |
| 329 | y.append(item) |
| 330 | if dictiter is not None: |
| 331 | for key, value in dictiter: |
| 332 | if deep: |
| 333 | key = deepcopy(key, memo) |
| 334 | value = deepcopy(value, memo) |
| 335 | y[key] = value |
Guido van Rossum | 6cef6d5 | 2001-09-28 18:13:29 +0000 | [diff] [blame] | 336 | if state: |
| 337 | if deep: |
Guido van Rossum | 1e91c14 | 2001-12-28 21:33:22 +0000 | [diff] [blame] | 338 | state = deepcopy(state, memo) |
Guido van Rossum | 3e3583c | 2002-06-06 17:41:20 +0000 | [diff] [blame] | 339 | if hasattr(y, '__setstate__'): |
| 340 | y.__setstate__(state) |
| 341 | else: |
Guido van Rossum | c755758 | 2003-02-06 19:53:22 +0000 | [diff] [blame] | 342 | if isinstance(state, tuple) and len(state) == 2: |
| 343 | state, slotstate = state |
| 344 | else: |
| 345 | slotstate = None |
| 346 | if state is not None: |
| 347 | y.__dict__.update(state) |
| 348 | if slotstate is not None: |
| 349 | for key, value in slotstate.iteritems(): |
| 350 | setattr(y, key, value) |
Guido van Rossum | 6cef6d5 | 2001-09-28 18:13:29 +0000 | [diff] [blame] | 351 | return y |
| 352 | |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 353 | del d |
| 354 | |
| 355 | del types |
| 356 | |
Guido van Rossum | c5d2d51 | 1997-12-07 16:18:22 +0000 | [diff] [blame] | 357 | # Helper for instance creation without calling __init__ |
| 358 | class _EmptyClass: |
| 359 | pass |
| 360 | |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 361 | def _test(): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 362 | l = [None, 1, 2L, 3.14, 'xyzzy', (1, 2L), [3.14, 'abc'], |
| 363 | {'abc': 'ABC'}, (), [], {}] |
| 364 | l1 = copy(l) |
| 365 | print l1==l |
| 366 | l1 = map(copy, l) |
| 367 | print l1==l |
| 368 | l1 = deepcopy(l) |
| 369 | print l1==l |
| 370 | class C: |
| 371 | def __init__(self, arg=None): |
| 372 | self.a = 1 |
| 373 | self.arg = arg |
| 374 | if __name__ == '__main__': |
| 375 | import sys |
| 376 | file = sys.argv[0] |
| 377 | else: |
| 378 | file = __file__ |
| 379 | self.fp = open(file) |
| 380 | self.fp.close() |
| 381 | def __getstate__(self): |
| 382 | return {'a': self.a, 'arg': self.arg} |
| 383 | def __setstate__(self, state): |
Raymond Hettinger | e0d4972 | 2002-06-02 18:55:56 +0000 | [diff] [blame] | 384 | for key, value in state.iteritems(): |
| 385 | setattr(self, key, value) |
Guido van Rossum | c06e3ac | 2003-02-07 17:30:18 +0000 | [diff] [blame] | 386 | def __deepcopy__(self, memo=None): |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 387 | new = self.__class__(deepcopy(self.arg, memo)) |
| 388 | new.a = self.a |
| 389 | return new |
| 390 | c = C('argument sketch') |
| 391 | l.append(c) |
| 392 | l2 = copy(l) |
| 393 | print l == l2 |
| 394 | print l |
| 395 | print l2 |
| 396 | l2 = deepcopy(l) |
| 397 | print l == l2 |
| 398 | print l |
| 399 | print l2 |
| 400 | l.append({l[1]: l, 'xyz': l[2]}) |
| 401 | l3 = copy(l) |
| 402 | import repr |
| 403 | print map(repr.repr, l) |
| 404 | print map(repr.repr, l1) |
| 405 | print map(repr.repr, l2) |
| 406 | print map(repr.repr, l3) |
| 407 | l3 = deepcopy(l) |
| 408 | import repr |
| 409 | print map(repr.repr, l) |
| 410 | print map(repr.repr, l1) |
| 411 | print map(repr.repr, l2) |
| 412 | print map(repr.repr, l3) |
Guido van Rossum | 409780f | 1995-01-10 00:34:21 +0000 | [diff] [blame] | 413 | |
| 414 | if __name__ == '__main__': |
Tim Peters | 88869f9 | 2001-01-14 23:36:06 +0000 | [diff] [blame] | 415 | _test() |