Python中的浅复制和深复制|极客笔记

Python中的浅复制和深复制

在本教程中，我们将学习如何使用Python脚本创建浅复制和深复制。通常，我们使用=（赋值运算符）来创建Python对象的副本。让我们了解有关在Python中创建副本的完整概念。

Python中的复制

众所周知，赋值运算符用于创建Python对象的副本，但这是不准确的；它只创建目标和对象之间的绑定。当我们使用赋值运算符时，它不会创建一个新对象，而是创建一个共享旧对象引用的新变量。

复制在用户希望在不同时修改原始对象的情况下非常有用。用户也喜欢创建副本来处理可变对象。

让我们了解以下示例：

示例

list1 = [[1, 2, 3], [4, 5, 6], [7, 8, 'a']]
list2 = list1

list2[1][2] = 4

print('Old List:', list1)
print('ID of Old List:', id(list1))

print('New List:', list2)
print('ID of New List:', id(list2))

输出：

Old List: [[1, 2, 3], [4, 5, 4], [7, 8, 'a']]
ID of Old List: 1909447368968
New List: [[1, 2, 3], [4, 5, 4], [7, 8, 'a']]
ID of New List: 1909447368968

解释 –

在上面的输出中，我们可以看到变量 list1 和 list2 共享相同的 id 1909447368968。

如果我们对 list1 或 list2 中的任何值进行任何更改，更改将反映在两者中。

Python 中的拷贝类型

主要目的是创建 Python 对象的副本，我们可以修改副本而不更改原始数据。在 Python 中，有两种方法可以创建副本。

浅拷贝
深拷贝

我们将使用 copy 模块来创建上述副本。

copy 模块

copy 模块用于创建浅拷贝和深拷贝。让我们看看每种方法。

浅拷贝

浅拷贝是对象的一个副本，它存储原始元素的引用。它创建一个新的集合对象，然后使用原始对象中的子对象的引用来填充它。

它会复制嵌套对象的引用，而不会创建嵌套对象的副本。因此，如果我们对对象的副本进行任何更改，会反映在原始对象中。我们将使用 copy() 函数来实现。

示例

# importing "copy" for copy operations 
import copy 

# initializing list 1 
list1 = [1, 7, [3,5], 8] 

# using copy to shallow copy 
list2 = copy.copy(list1) 

# original elements of list 
print ("The original elements before shallow copying") 
for i in range(0,len(list1)): 
   print (list1[i],end=" ") 

print("\r") 

# adding and element to new list 
list2[2][0] = 10

# checking if change is reflected 
print ("The original elements after shallow copying") 
for i in range(0,len( list1)): 
   print (list1[i],end=" ")

输出：

The original elements before shallow copying
1 7 [3, 5] 8 
The original elements after shallow copying
1 7 [10, 5] 8

在上述代码中，我们对list1进行了更改，这种更改反映在另一个列表中。

示例2

import copy

list1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
list2 = copy.copy(list1)

list1.append([13, 14,15])

print("Old list:", list1)
print("New list:", list2)

输出:

Old list: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]
New list: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]

解释 –

在上面的代码中，我们创建了list1的浅拷贝。新创建的list2包含了对存储在list1中的原始嵌套对象的引用。然后，我们将[13, 14, 15]附加到旧列表中，并且子列表未被复制到新列表中。

Python中的深拷贝

深拷贝是一种创建新对象并递归复制元素的过程。我们将使用copy模块中的deepcopy()方法。独立的副本将被创建，其中包括原始对象及其所有对象。让我们理解以下示例。

示例

import copy
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
z = copy.deepcopy(xs)
print(x)
prin(z)

输出：

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

解释 –

在上面的输出中，我们可以看到我们使用 deepcopy() 方法创建的z是x的一个克隆。如果我们对其中一个子对象进行更改，不会影响原始对象。

深拷贝中，这两个对象是完全独立的。列表x被递归地克隆，包括其所有子对象。

import copy
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
z = copy.deepcopy(x)

x[2][2] = 'Hello'
print(x)

示例2：

import copy 

list1 = [0, [1, 2], [3,5], 4] 

# using deepcopy to deep copy 
list2 = copy.deepcopy(list1) 

# original elements of list 
print ("The original list: ")
for i in range(0,len(list1)): 
   print (list1[i],end=" ") 

print("\r") 

# adding and element to new list 
list2[1][0] = 8

# Change is reflected in l2 
print ("The new list after deep copying: ")
for i in range(0,len( list1)): 
   print (list2[i],end=" ") 

print("\r") 

# Change is NOT reflected in original list 
# as it is a deep copy 
print ("The original elements:")
for i in range(0,len( list1)): 
   print (list1[i],end=" ")

输出：

The original list: 
0 [1, 2] [3, 5] 4 
The new list after deep copying: 
0 [8, 2] [3, 5] 4 
The original elements:
0 [1, 2] [3, 5] 4

复制任意的Python对象

我们还可以使用copy方法复制任意的Python对象，包括自定义类。可以使用copy.copy()和copy.deepcopy()方法来复制任何对象。

让我们来看下面的示例。

示例

import copy
class Func_New:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
      return 'Func_new(%r, %r)' % (self.x, self.y)

a = Func_New(50, 56)
b = copy.copy(a)

print(a)
print(b)

print(a is b)
print(b is a)

输出：

Func_new(50, 56)
Func_new(50, 56)
False
False

解释 –

在上述代码中，我们创建了一个名为 Func_new 的用户定义类，并定义了 __repr__() 来检查对象。接下来，我们使用copy模块创建了浅复制。我们实例化了该类并检查了原始对象及其浅复制。

要记住的要点

复合对象是浅复制和深复制的主要区别。包含其他对象（如列表或类实例）的对象称为列表或类实例。

浅复制会创建一个新的复合对象，然后在原始对象中添加对该对象的引用。
深复制会创建一个新的复合对象，并在原始对象中添加对该对象的引用。
我们可以使用copy模块复制任意对象（包括自定义类）。

Python中的浅复制和深复制