Python中的对象之间赋值时是按引用传递的,假诺必要拷贝对象,须要使用标准库中的copy模块。

Python中,对象的赋值,拷贝(深/浅拷贝)之间是有差异的,要是选取的时候不注意,就只怕爆发意料之外的结果。
上面本文就由此不难的例子介绍一下那个概念之间的出入。

原稿出处:<a>;

图解Python深拷贝和浅拷贝

Python中,对象的赋值,拷贝(深/浅拷贝)之间是有差别的,假若应用的时候不留心,就恐怕产生意想不到的结果。

 

上边本文就经过简单的事例介绍一下这几个概念之间的距离。

 

对象赋值

一向看一段代码:

 

 

will = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = will
print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

will[0] = "Wilber"
will[2].append("CSS")
print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

 

 

 

代码的输出为:

 

 

 

上边来分析一下那段代码:

 

率先,创立了八个名为will的变量,那么些变量指向3个list对象,从第二张图中得以看出所有指标的地点(每一回运转,结果可能两样)

下一场,通过will变量对wilber变量举办赋值,那么wilber变量将对准will变量对应的目的(内部存款和储蓄器地址),也正是说”wilber
is will”,”wilber[i] is will[i]”

能够清楚为,Python中,对象的赋值都是开展对象引用(内部存款和储蓄器地址)传递

其三张图中,由于will和wilber指向同3个对象,所以对will的别的改动都会反映在wilber上

这里供给专注的某个是,str是不可变类型,所以当修改的时候会交替旧的目的,发生2个新的地点39758496

 

 

浅拷贝

上面就来看看浅拷贝的结果:

 

 

import copy

will = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = copy.copy(will)

print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

will[0] = "Wilber"
will[2].append("CSS")
print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

 

代码结果为:

 

 

 

浅析一下那段代码:

 

率先,还是选拔贰个will变量,指向2个list类型的靶子

接下来,通过copy模块里面包车型地铁浅拷贝函数copy(),对will指向的靶子进行浅拷贝,然后浅拷贝生成的新对象赋值给wilber变量

浅拷贝会创立2个新的对象,那些例子中”wilber is not will”

可是,对于目的中的成分,浅拷贝就只会动用原始成分的引用(内存地址),也正是说”wilber[图解Python深拷贝和浅拷贝,深拷贝和浅拷贝。i]
is will[i]”

当对will举办修改的时候

出于list的率先个要素是不行变类型,所以will对应的list的第3个成分会使用一个新的对象39758496

唯独list的第三个因素是1个可不类型,修改操作不会爆发新的指标,所以will的修改结果会相应的反响到wilber上

 

 

小结一下,当大家使用下边包车型大巴操作的时候,会爆发浅拷贝的功力:

 

使用切片[:]操作

利用工厂函数(如list/dir/set)

运用copy模块中的copy()函数

深拷贝

说到底来探视深拷贝:

 

 

import copy

will = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = copy.deepcopy(will)

print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

will[0] = "Wilber"
will[2].append("CSS")
print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

 

 

 

代码的结果为:

 

 

 

浅析一下那段代码:

 

首先,同样采取1个will变量,指向二个list类型的对象

下一场,通过copy模块里面包车型大巴深拷贝函数deepcopy(),对will指向的目标开始展览深拷贝,然后深拷贝生成的新对象赋值给wilber变量

跟浅拷贝类似,深拷贝也会成立多个新的对象,这几个事例中”wilber is not will”

然则,对于目的中的成分,深拷贝都会再也生成一份(有独特意况,上面会表明),而不是不难的施用原始成分的引用(内部存储器地址)

事例中will的首个要素指向39737304,而wilber的第多个要素是1个全新的靶子39773088,相当于说,”wilber[2]
is not will[2]”

当对will进行修改的时候

出于list的率先个成分是不足变类型,所以will对应的list的首先个因素会选用贰个新的对象39758496

不过list的第伍个要素是二个可不类型,修改操作不会产生新的靶子,不过出于”wilber[2]
is not will[2]”,所以will的改动不会影响wilber

 

 

拷贝的奇异情状

实际,对于拷贝有一些新鲜情况:

 

对此非容器类型(如数字、字符串、和其余’原子’类型的指标)没有拷贝这一说

也正是说,对于这个项目,”obj is copy.copy(obj)” 、”obj is
copy.deepcopy(obj)”

只要元祖变量只含有原子类型对象,则不能够深拷贝,看下边包车型地铁事例

    

 

总结

本文介绍了目的的赋值和拷贝,以及它们之间的异样:

 

Python中指标的赋值都以开展对象引用(内存地址)传递

应用copy.copy(),能够展开对象的浅拷贝,它复制了目的,但对此指标中的成分,依然采纳原来的引用.

一经急需复制二个容器对象,以及它里面包车型客车享有因素(包涵成分的子元素),能够应用copy.deepcopy()举行深拷贝

对于非容器类型(如数字、字符串、和其他’原子’类型的对象)没有被拷贝一说

假定元祖变量只含有原子类型对象,则不能够深拷贝,看上边包车型地铁例证

Python中,对象的赋值,拷贝(深/浅拷贝)之间是有差别的,假使使用的时候不理会,就只怕产生意料之外的结果。
下…

① 、copy.copy 浅拷贝 只拷贝父对象,不会拷贝对象的内部的子对象。

指标赋值

直白看一段代码:

will = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = will
print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

will[0] = "Wilber"
will[2].append("CSS")
print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

代码的输出为:

金沙注册送58 1

赋值拷贝

上边来分析一下那段代码:

金沙注册送58 2

赋值拷贝内部存款和储蓄器分析

率先,成立了三个名为will的变量,那个变量指向多少个list对象,从第叁张图中得以看出有着目的的地方(每一趟运转,结果恐怕差异)
接下来,通过will变量对wilber变量进行赋值,那么wilber变量将本着will变量对应的靶子(内部存款和储蓄器地址),也正是说”wilber
is will”,”wilber[i] is will[i]”

能够清楚为,Python中,对象的赋值都以开始展览对象引用(内部存款和储蓄器地址)传递
其三张图中,由于will和wilber指向同3个指标,所以对will的任何改动都会显示在wilber上
那里须要留意的一点是,str是不行变类型,所以当修改的时候会交替旧的靶子,发生3个新的地点39758496

Python中,对象的赋值,拷贝(深/浅拷贝)之间是有反差的,借使运用的时候不在意,就大概产生意料之外的结果。

② 、copy.deepcopy 深拷贝 拷贝对象及其子对象

浅拷贝

下边就来探视浅拷贝的结果:

import copy

will = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = copy.copy(will)

print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

will[0] = "Wilber"
will[2].append("CSS")
print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

代码结果为:

金沙注册送58 3

浅拷贝

剖析一下那段代码:

金沙注册送58 4

浅拷贝内部存储器分析

率先,照旧选取2个will变量,指向1个list类型的对象
然后,通过copy模块里面的浅拷贝函数copy(),对will指向的对象进行浅拷贝,然后浅拷贝生成的新对象赋值给wilber变量
浅拷贝会创立二个新的目的,这一个例子中”wilber is not will”
可是,对于指标中的成分,浅拷贝就只会采纳原始成分的引用(内部存款和储蓄器地址),也正是说”wilber[i]
is will[i]”
当对will实行修改的时候
是因为list的第3个因素是不可变类型,所以will对应的list的率先个要素会使用1个新的靶子39758496
只是list的第四个元素是1个可不类型,修改操作不会发生新的对象,所以will的改动结果会相应的反响到wilber上

总括一下,当我们选取上面包车型地铁操作的时候,会发生浅拷贝的成效:

使用切片[:]操作
使用工厂函数(如list/dir/set)
使用copy模块中的copy()函数

上边大家遵照原著,细细精晓下那么些出入:

 

深拷贝

末段来看望深拷贝:

import copy

will = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = copy.deepcopy(will)

print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]

will[0] = "Wilber"
will[2].append("CSS")
print id(will)
print will
print [id(ele) for ele in will]
print id(wilber)
print wilber
print [id(ele) for ele in wilber]
{% endcodeblock %}

代码的结果为:

金沙注册送58 5

深拷贝

分析一下那段代码:

金沙注册送58 6

深拷贝内部存款和储蓄器分析

首先,同样使用3个will变量,指向叁个list类型的指标
下一场,通过copy模块里面包车型客车深拷贝函数deepcopy(),对will指向的靶子开始展览深拷贝,然后深拷贝生成的新对象赋值给wilber变量
跟浅拷贝类似,深拷贝也会创设一个新的对象,这几个事例中”wilber is not
will”
唯独,对于目的中的元素,深拷贝都会重新生成一份(有出色情状,下边会表明),而不是大致的施用原始成分的引用(内部存款和储蓄器地址)
事例中will的第二个成分指向39737304,而wilber的第⑨个因素是三个簇新的对象39773088,也便是说,”wilber[2]
is not will[2]”
当对will举办修改的时候
是因为list的首先个因素是不可变类型,所以will对应的list的率先个要素会选拔多个新的靶子39758496
但是list的第④个因素是三个可不类型,修改操作不会发出新的目的,不过由于”wilber[2]
is not will[2]”,所以will的改动不会潜移默化wilber

指标赋值

我们看下边包车型大巴的代码部分:

In [1]: will = ["will",28,["python","C#","Javascript"]]

In [2]: wilber = will

In [3]: id(will)
Out[3]: 2335727905096

In [4]: id(wilber)
Out[4]: 2335727905096

In [5]: print([id(ele) for ele in will])
[2335725285536, 1453458736, 2335727904456]

In [6]: print([id(ele) for ele in wilber])
[2335725285536, 1453458736, 2335727904456]

In [7]: will[0] = "wilber"

In [8]: will[2].append("CSS")

In [9]: id(will)
Out[9]: 2335727905096

In [10]: id(wilber)
Out[10]: 2335727905096

In [11]: print([id(ele) for ele in will])
[2335727892328, 1453458736, 2335727904456]

In [12]: print([id(ele) for ele in wilber])
[2335727892328, 1453458736, 2335727904456]

咱俩解析下这段代码:

  • 第三,创设了一个名为will的变量,那几个变量指向一个list对象,从第壹张图中能够看看有着目的的地址(每一遍运营,结果也许区别)
  • 然后,通过will变量对wilber变量进行赋值,那么wilber变量将针对will变量对应的指标(内部存款和储蓄器地址),约等于说”wilber
    is will”,”wilber[i] is will[i]”

能够精通为,Python中,对象的赋值都以开始展览对象引用(内部存款和储蓄器地址)传递

  • 其三张图中,由于will和wilber指向同二个目的,所以对will的别样改动都会议及展览示在wilber上

那里要求专注的少数是,str是不足变类型,所以当修改的时候会交替旧的对象,发生一个新的地址。

为了便利驾驭,我将原来的作品的图样直接拷贝过来,里面内部存款和储蓄器地址编号和代码不平等。

Paste_Image.png

那篇博客首要透过代码说美赞臣(Meadjohnson)下指标赋值、浅拷贝和深拷贝三者的分别。

奇异景况

实质上,对于拷贝有部分奇异意况:
对于非容器类型(如数字、字符串、和此外’原子’类型的目的)没有拷贝这一说
也正是说,对于这么些品种,”obj is copy.copy(obj)” 、”obj is
copy.deepcopy(obj)”
设若元组变量只包括原子类型对象,则不可能深拷贝,看上面的事例

金沙注册送58 7

特种情况

浅拷贝

上边看看浅拷贝

In [1]: import copy

In [2]: will = ["Will", 28, ["Python", "C#", "JavaScript"]]

In [3]: wilber = copy.copy(will)

In [4]: id(will)
Out[4]: 2899569681288

In [5]: id(wilber)
Out[5]: 2899583552712

In [6]: print([id(ele) for ele in will])
[2899583263664, 1453458736, 2899585719944]

In [7]: print([id(ele) for ele in wilber])
[2899583263664, 1453458736, 2899585719944]

In [8]: will[0] = "wilber"

In [9]: will[2].append("CSS")

In [10]: id(will)
Out[10]: 2899569681288

In [11]: id(wilber)
Out[11]: 2899583552712

In [12]: print([id(ele) for ele in will])
[2899586038616, 1453458736, 2899585719944]

In [13]: print([id(ele) for ele in wilber])
[2899583263664, 1453458736, 2899585719944]

In [14]: will
Out[14]: ['wilber', 28, ['Python', 'C#', 'JavaScript', 'CSS']]

In [15]: wilber
Out[15]: ['Will', 28, ['Python', 'C#', 'JavaScript', 'CSS']]

浅析下那段代码:

  • 首先,照旧采纳三个will变量,指向三个list类型的靶子
  • 然后,通过copy模块里面包车型大巴浅拷贝函数copy(),对will指向的对象开始展览浅拷贝,然后浅拷贝生成的新对象赋值给wilber变量

浅拷贝会创建贰个新的对象,这几个例子中”wilber is not will”
唯独,对于指标中的成分,浅拷贝就只会使用原始成分的引用(内部存款和储蓄器地址),也便是说”wilber[i]
is will[i]”

  • 当对will进行改动的时候
    出于list的率先个要素是不足变类型,所以will对应的list的第3个因素会动用3个新的对象表示。
    不过list的第十个要素是八个可变类型,修改操作不会生出新的靶子,所以will的改动结果会相应的反应到wilber上

Paste_Image.png

小结一下,当大家选取上边的操作的时候,会生出浅拷贝的法力:

  • 使用切片[:]操作
  • 利用工厂函数(如list/dir/set)
  • 运用copy模块中的copy()函数

第1区分一下可变对象和不可变对象:

总结

正文介绍了对象的赋值和拷贝,以及它们中间的歧异:

  • Python中目的的赋值都以展开对象引用(内部存款和储蓄器地址)传递
  • 使用copy.copy(),能够开始展览对象的浅拷贝,它复制了目的,但对于目标中的成分,如故选择原有的引用.
  • 一旦供给复制叁个器皿对象,以及它当中的兼具因素(包蕴成分的子元素),能够使用copy.deepcopy()实行深拷贝
  • 对此非容器类型(如数字、字符串、和别的’原子’类型的指标)没有被拷贝一说。
  • 借使元祖变量只含有原子类型对象,则不可能深拷贝。

作者:田小安插
出处:http://www.cnblogs.com/wilber2013/

金沙注册送58 ,深拷贝

说到底我们看看深拷贝

In [1]: import copy

In [2]:  will = ["Will", 28, ["Python", "C#", "JavaScript"]]

In [3]: wilber = copy.deepcopy(will)

In [4]: id(will)
Out[4]: 2871945438664

In [5]: id(wilber)
Out[5]: 2871945199048

In [6]: print([id(ele) for ele in will])
[2871945176264, 1453458736, 2871945207496]

In [7]: print([id(ele) for ele in wilber])
[2871945176264, 1453458736, 2871945341256]

In [8]: will[0] = "wilber"

In [9]: will[2].append("CSS")

In [10]: will
Out[10]: ['wilber', 28, ['Python', 'C#', 'JavaScript', 'CSS']]

In [11]: id(will)
Out[11]: 2871945438664

In [12]: id(wilber)
Out[12]: 2871945199048

In [13]: wilber
Out[13]: ['Will', 28, ['Python', 'C#', 'JavaScript']]

In [14]: print([id(ele) for ele in will])
[2871945496928, 1453458736, 2871945207496]

In [15]: print([id(ele) for ele in wilber])
[2871945176264, 1453458736, 2871945341256]

剖析一下这段代码:

  • 先是,同样选拔一个will变量,指向1个list类型的目的
  • 接下来,通过copy模块里面包车型地铁深拷贝函数deepcopy(),对will指向的对象开始展览深拷贝,然后深拷贝生成的新对象赋值给wilber变量

跟浅拷贝类似,深拷贝也会创立一个新的指标,这几个事例中”wilber is not
will”
但是,对于指标中的成分,深拷贝都会再度生成一份(有特有景况,下边会表达),而不是简约的使用原始成分的引用(内部存款和储蓄器地址)

事例中will的第八个成分指向287一九四五207496,而wilber的第一个因素是3个簇新的目的2871944341256,也正是说,”wilber[2]
is not will[2]”

  • 当对will进行修改的时候
    出于list的首先个要素是不行变类型,所以will对应的list的率先个成分会动用八个新的靶子2871944496928

而是list的第两个因素是2个可变类型,修改操作不会发出新的目的,不过出于”wilber[2]
is not will[2]”,所以will的改动不会影响wilber

Paste_Image.png

  • 不可变对象:一旦创制就不行修改的指标,包蕴字符串、元组、数字 
  • 可变对象:能够修改的指标,包罗列表、字典。
拷贝的新鲜景况

骨子里,对于拷贝有一部分特有情形:

  • 对于非容器类型(如数字、字符串、和其余’原子’类型的指标)没有拷贝这一说
    也正是说,对于这一个品种,”obj is copy.copy(obj)” 、”obj is
    copy.deepcopy(obj)”

  • 假诺元祖变量只包涵原子类型对象,则无法深拷贝,看上面包车型地铁事例

In [16]:  book =("python","c#","Javascript")

In [17]: copies = copy.deepcopy(book)

In [18]: book is copies
Out[18]: True

In [19]:  book =("python","c#","Javascript",[])

In [20]: copies = copy.deepcopy(book)

In [21]: book is copies
Out[21]: False

本文介绍了对象的赋值和拷贝,以及它们之间的距离:

  • Python中指标的赋值都以举办对象引用(内部存款和储蓄器地址)传递
  • 行使copy.copy(),能够开始展览对象的浅拷贝,它复制了对象,但对于目的中的成分,依然选取原有的引用.
  • 即使要求复制二个器皿对象,以及它里面包车型大巴持有因素(包罗成分的子成分),能够运用copy.deepcopy()进行深拷贝
  • 对此非容器类型(如数字、字符串、和别的’原子’类型的对象)没有被拷贝一说
  • 一旦元组变量只含有原子类型对象,则不能够深拷贝,

动用范围:

  • 切开可以使用于:列表、元组、字符串,但不能够应用于字典。 
  • 浓度拷贝,既可利用系列(列表、元组、字符串),也可选用字典。

 

对象赋值:

will = ["train", 28, ["File", "Edit", "View"]]
wilber = will
print(id(will))
print(will)
print([id(ele) for ele in will])
print(id(wilber))
print(wilber)
print([id(ele) for ele in wilber])

will[0] = "test"
will[2].append("Navigate")
print(id(will))
print(will)
print([id(ele) for ele in will])
print(id(wilber))
print(wilber)
print([id(ele) for ele in wilber])

推行代码,结果为:

金沙注册送58 8

下面来分析一下那段代码:

  • 第二,成立了2个名为will的变量,那一个变量指向贰个list对象,从第2张图中能够看出全部指标的地方(每一趟运营,结果或许两样)
  • 接下来,通过will变量对wilber变量举行赋值,那么wilber变量将本着will变量对应的靶子(内部存储器地址),也等于说”wilber
    is will”,”wilber[i] is
    will[i]”能够清楚为,Python中,对象的赋值都是拓展对象引用(内部存款和储蓄器地址)传递
  • 其三张图中,由于will和wilber指向同多个目标,所以对will的别样改动都会体现在wilber上那里须要留意的一点是,str是不足变类型,所以当修改的时候会交替旧的目的,爆发2个新的地址2090725708104

 

浅拷贝:

import copy

will = ["train", 28, ["File", "Edit", "View"]]
wilber = copy.copy(will)

print(id(will))
print(will)
print([id(ele) for ele in will])
print(id(wilber))
print(wilber)
print([id(ele) for ele in wilber])

will[0] = "test"
will[2].append("Navigate")
print(id(will))
print(will)
print([id(ele) for ele in will])
print(id(wilber))
print(wilber)
print([id(ele) for ele in wilber])

执行代码,结果为:

金沙注册送58 9

上面来分析一下那段代码:

  • 先是,照旧采用二个will变量,指向3个list类型的指标
  • 下一场,通过copy模块里面包车型的士浅拷贝函数copy(),对will指向的靶子进行浅拷贝,然后浅拷贝生成的新对象赋值给wilber变量

    • 浅拷贝会成立1个新的靶子,这一个例子中“wilber is not will”
    • 唯独,对于目的中的成分,浅拷贝就只会动用原始元素的引用(内部存款和储蓄器地址),也正是说”wilber[i]
      is will[i]”
  • 当对will进行改动的时候

    • 鉴于list的首先个要素是不行变类型,所以will对应的list的首个成分会利用3个新的对象2425789321544
    • 但是list的第柒个因素是1个可变类型,修改操作不会产生新的目的,所以will的改动结果会相应的反馈到wilber上

当大家利用上边包车型地铁操作的时候,会发生浅拷贝的效果:

  • 选拔切片[:]操作
  • 行使工厂函数(如list/dir/set)
  • 采纳copy模块中的copy()函数

 

深拷贝:

import copy

will = ["train", 28, ["File", "Edit", "View"]]
wilber = copy.deepcopy(will)

print(id(will))
print(will)
print([id(ele) for ele in will])
print(id(wilber))
print(wilber)
print([id(ele) for ele in wilber])

will[0] = "test"
will[2].append("Navigate")
print(id(will))
print(will)
print([id(ele) for ele in will])
print(id(wilber))
print(wilber)
print([id(ele) for ele in wilber])

施行代码,结果为:

金沙注册送58 10

上面来分析一下那段代码:

  • 第贰,同样运用三个will变量,指向3个list类型的靶子
  • 接下来,通过copy模块里面包车型客车深拷贝函数deepcopy(),对will指向的对象开始展览深拷贝,然后深拷贝生成的新目的赋值给wilber变量

    • 跟浅拷贝类似,深拷贝也会创立五个新的目的,那些例子中“wilber is
      not will”
    • 可是,对于目的中的成分,深拷贝都会另行生成一份(有异样意况,上面会表明),而不是简约的运用原始成分的引用(内存地址)

      • 事例中will的第一个要素指向2822103840392,而wilber的第二个成分是1个簇新的对象2822084461768,也便是说,“wilber[2]
        is not will[2]”
  • 当对will举行改动的时候

    • 是因为list的首先个因素是不可变类型,所以will对应的list的率先个要素会利用1个新的靶子2822045929800
    • 唯独list的第二个成分是1个可不类型,修改操作不会发生新的指标,可是出于”wilber[2]
      is not will[2]”,所以will的修改不会影响wilber

 

拷贝的卓绝情形:

  • 对于非容器类型(如数字、字符串、和其余’原子’类型的对象)没有拷贝这一说

    • 约等于说,对于那个项目,”obj is copy.copy(obj)” 、”obj is
      copy.deepcopy(obj)”
  • 只要元祖变量只包涵原子类型对象,则不能够深拷贝,看上面包车型大巴事例

  • import copy

    will = ('File', 'Edit', 'View')
    wilber = copy.deepcopy(will)
    print(will is wilber)
    
    will = ('File', 'Edit', 'View', [])
    wilber = copy.deepcopy(will)
    print(will is wilber)
    

    金沙注册送58 11

 

总结:

  • Python中指标的赋值都以进展对象引用(内部存款和储蓄器地址)传递
  • 行使copy.copy(),可以展开对象的浅拷贝,它复制了指标,但对此目的中的成分,仍然接纳原来的引用.
  • 比方急需复制三个容器对象,以及它里面包车型地铁拥有因素(包涵成分的子成分),可以运用copy.deepcopy()进行深拷贝
  • 对此非容器类型(如数字、字符串、和别的’原子’类型的靶子)没有被拷贝一说
  • 设若元祖变量只包蕴原子类型对象,则无法深拷贝。

参考资料:

 

相关文章

网站地图xml地图