In-depth understanding of the copy module in python (shallow copy and deep copy)

Mainly introduces the copy module in python.

The copy module includes functions for creating deep and shallow copies of composite objects, including lists, tuples, dictionaries, and instances of user-defined objects.

#copy(x)

#Create a new composite object and Creates a shallow copy of x by copying its members by reference. To put it more deeply,

It copies the object, but still uses references for the elements in the object.

For built-in types, this function is not often used.

Instead, use calling methods such as list(x), dict(x), set(x), etc. to create a shallow copy of x. You must know that

directly using the type name is obviously better than Using copy() is much faster. But they achieve the same effect.

Another point is for those objects that cannot be modified (string, number, tuple), because you don’t have to worry about modifying them. Copying or not does not make much sense.

Another point, you can use the is operator to determine whether objects are copied.

a is b -> True a and b refer to the same object, not copies

-> False a and b are copies of each other

For example, as follows Example, eg:

(1)

>>> a = [1,2,3]

>>> b = copy .copy(a)

>>> b

[1, 2, 3]

>>> a.append(4)

>>> a

[1, 2, 3, 4]

>>> b

[1, 2, 3]

>>> a is b

False

(2)

>>> a = [1,2,3 ]

>>> b = a

>>> b

[1, 2, 3]

>> > a.append(4)

>>> a

[1, 2, 3, 4]

>>> b

[1, 2, 3, 4]

>>> b.append(6)

>>> a, b

([1, 2, 3, 4, 6], [1, 2, 3, 4, 6])

(3)

>>> a = [1 ,2,3]

>>> b = list(a)

>>> b

[1, 2, 3]

>>> a.append(4)

>>> a

[1, 2, 3, 4]

> ;>> b

[1, 2, 3]

>>>

(4)

>>> ; a = [[1], ['a'], ['A']]

>>> b = copy.copy(a)

>> > print a, b

[[1], ['a'], ['A']] [[1], ['a'], ['A']]

>>> b[1].append('b')

>>> b

[[1], ['a', 'b'] , ['A']]

>>> a

[[1], ['a', 'b'], ['A']]

>>> b.append([100,101])

>>> b

[[1], ['a', 'b'], [ 'A'], [100, 101]]

>>> a

[[1], ['a', 'b'], ['A']]

In the example (3), we can see the shallow copy object b of a. They are different objects, so changes to the objects will not

### affect each other, but these The elements of objects a and b refer to the same, so if a or b changes the elements of its object, it will affect ###

Another value.

If you want to completely copy an object and the values ​​of all elements of an object, only use the deepcopy() function below.

#deepcopy(x[, visit])

## Create a deep copy of x by creating a new composite object and repeatedly copying all members of x.

visit is an optional dictionary whose purpose is to keep track of visited objects, thereby detecting and avoiding repeated cycles in data structures that define

.

Although it is not usually needed, by implementing the methods __copy__(self) and __deepcopy__(self, visit), the

class can implement custom copy methods. These two The methods implement shallow copy and deep copy operations respectively.

__deepcopy__() method must use the dictionary visit to track previously encountered objects during the copy process. For the

__deepcopy__() method, there is no need to

beyond passing the visit to the other deepcopy() methods included in the implementation (if any).

If the class implements the methods __getstate__() and __setstate__() used by the pickle module, then the copy module will use

these methods to create a copy.

, but by implementing the methods __copy__(self) and __deepcopy__(self, visit), the

class can implement a custom copy method. These two methods implement shallow copy respectively. and deep copy operations.

__deepcopy__() method must use the dictionary visit to track previously encountered objects during the copy process. For the

__deepcopy__() method, there is no need to

beyond passing the visit to the other deepcopy() methods included in the implementation (if any).

If the class implements the methods __getstate__() and __setstate__() used by the pickle module, then the copy module will use

these methods to create a copy. , but by implementing the methods __copy__(self) and __deepcopy__(self, visit), the

class can implement a custom copy method. These two methods implement shallow copy and deep copy operations respectively.

__deepcopy__() method must use the dictionary visit to track previously encountered objects during the copy process. For the

__deepcopy__() method, there is no need to

beyond passing the visit to the other deepcopy() methods included in the implementation (if any).

If the class implements the methods __getstate__() and __setstate__() used by the pickle module, then the copy module will use

these methods to create a copy.

eg:

>>> a = [[1], ['a'], ['A']]

>>> ; import copy

>>> b = copy.deepcopy(a)

>>> b

[[1], ['a' ], ['A']]

>>> c = copy.copy(a)

>>> c

[[1] , ['a'], ['A']]

>>> a[1].append('b')

>>> a

[[1], ['a', 'b'], ['A']]

>>> b

###[[1], [' a'], ['A']]######>>> c######[[1], ['a', 'b'], ['A']]# #####Things to note: ######(1) The copy module is used for simple types like integers and strings, but this is rarely needed. ######(2) These copy functions cannot work with modules, class objects, functions, methods, tracebacks, stack frames, files, sockets and other similar types. ######If the object cannot be copied, a copy.error exception will be raised. ###

The above is the detailed content of In-depth understanding of the copy module in python (shallow copy and deep copy). For more information, please follow other related articles on the PHP Chinese website!