python的浅拷贝和深拷贝,图解Python深拷贝和浅拷贝

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的变量,那些变量指向三个list对象,从第二张图中能够看出有着目的的地点(每一次运营,结果可能分歧)

接下来,通过will变量对wilber变量实行赋值,那么wilber变量将本着will变量对应的靶子(内存地址),也便是说”wilber
is will”,”wilber[i] is will[i]”

能够知晓为,Python中,对象的赋值都以举办对象引用(内部存款和储蓄器地址)传递

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

此处需求留意的一点是,str是不可变类型,所以当修改的时候会交替旧的目的,发生一个新的地方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变量,指向三个list类型的靶子

然后,通过copy模块里面包车型客车浅拷贝函数copy(),对will指向的对象举办浅拷贝,然后浅拷贝生成的新目的赋值给wilber变量

浅拷贝会创建八个新的指标,那个事例中”wilber is not will”

不过,对于指标中的成分,浅拷贝就只会动用原始成分的引用(内部存款和储蓄器地址),也正是说”wilber[i]
is will[i]”

当对will进行改动的时候

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

只是list的第多个要素是叁个可不类型,修改操作不会发生新的靶子,所以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]

 

 

 

代码的结果为:

 

 

 

剖析一下这段代码:

 

首先,同样采纳三个will变量,指向三个list类型的靶子

然后,通过copy模块里面包车型客车深拷贝函数deepcopy(),对will指向的对象实行深拷贝,然后深拷贝生成的新对象赋值给wilber变量

跟浅拷贝类似,深拷贝也会创设3个新的靶子,那个事例中”wilber is not will”

可是,对于指标中的元素,深拷贝都会再一次生成一份(有尤其情形,上面会表达),而不是粗略的施用原始成分的引用(内部存款和储蓄器地址)

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

当对will举办修改的时候

由于list的首先个因素是不可变类型,所以will对应的list的率先个要素会使用三个新的指标39758496

只是list的第多个成分是2个可不类型,修改操作不会爆发新的指标,不过由于”wilber[2]
is not will[python的浅拷贝和深拷贝,图解Python深拷贝和浅拷贝。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]

代码的输出为:

美高梅开户网址 1

赋值拷贝

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

美高梅开户网址 2

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

第②,创立了3个名为will的变量,这些变量指向三个list对象,从第贰张图中可以看到有着指标的地点(每趟运转,结果也许不一致)
然后,通过will变量对wilber变量进行赋值,那么wilber变量将针对will变量对应的指标(内部存款和储蓄器地址),约等于说”wilber
is will”,”wilber[i] is will[i]”

可以理解为,Python中,对象的赋值都以进行对象引用(内存地址)传递
其三张图中,由于will和wilber指向同三个指标,所以对will的其他修改都会议及展览示在wilber上
此处要求小心的一些是,str是不行变类型,所以当修改的时候会交替旧的靶子,爆发1个新的地方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]

代码结果为:

美高梅开户网址 3

浅拷贝

解析一下那段代码:

美高梅开户网址 4

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

先是,依旧接纳二个will变量,指向3个list类型的目的
下一场,通过copy模块里面包车型地铁浅拷贝函数copy(),对will指向的靶子进行浅拷贝,然后浅拷贝生成的新对象赋值给wilber变量
浅拷贝会创造多少个新的对象,那么些事例中”wilber is not will”
只是,对于目的中的成分,浅拷贝就只会动用原始成分的引用(内部存款和储蓄器地址),也正是说”wilber[i]
is will[i]”
美高梅开户网址,当对will举行改动的时候
出于list的率先个要素是不足变类型,所以will对应的list的第一个因素会利用五个新的对象39758496
然则list的第四个要素是一个可不类型,修改操作不会时有发生新的靶子,所以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 %}

代码的结果为:

美高梅开户网址 5

深拷贝

分析一下那段代码:

美高梅开户网址 6

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

首先,同样运用2个will变量,指向一个list类型的靶子
然后,通过copy模块里面包车型地铁深拷贝函数deepcopy(),对will指向的对象开始展览深拷贝,然后深拷贝生成的新对象赋值给wilber变量
跟浅拷贝类似,深拷贝也会创设二个新的靶子,那一个事例中”wilber is not
will”
不过,对于目的中的成分,深拷贝都会再次生成一份(有特有意况,下边会表明),而不是粗略的使用原始成分的引用(内部存储器地址)
事例中will的第陆个因素指向39737304,而wilber的第二个要素是一个崭新的靶子39773088,也等于说,”wilber[2]
is not will[2]”
当对will实行改动的时候
由于list的第③个因素是不可变类型,所以will对应的list的率先个要素会接纳3个新的靶子39758496
然而list的第多个因素是2个可不类型,修改操作不会产生新的指标,然则由于”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指向同1个目标,所以对will的其余修改都会映现在wilber上

那边供给注意的少数是,str是不足变类型,所以当修改的时候会交替旧的对象,爆发三个新的地址。

为了便于通晓,笔者将原来的小说的图纸直接拷贝过来,里面内部存款和储蓄器地址编号和代码分裂。

Paste_Image.png

那篇博客首要通过代码说贝拉米(Dumex)下对象赋值、浅拷贝和深拷贝三者的分歧。

破例情状

实则,对于拷贝有一对与众分裂意况:
对于非容器类型(如数字、字符串、和别的’原子’类型的靶子)没有拷贝这一说
约等于说,对于那些品种,”obj is copy.copy(obj)” 、”obj is
copy.deepcopy(obj)”
假如元组变量只含有原子类型对象,则不可能深拷贝,看上边包车型大巴例证

美高梅开户网址 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变量

浅拷贝会成立1个新的对象,这一个事例中”wilber is not will”
可是,对于目的中的成分,浅拷贝就只会动用原始成分的引用(内部存款和储蓄器地址),也正是说”wilber[i]
is will[i]”

  • 当对will举办修改的时候
    是因为list的首先个因素是不可变类型,所以will对应的list的率先个要素会利用一个新的靶子表示。
    而是list的第二个因素是贰个可变类型,修改操作不会发出新的指标,所以will的改动结果会相应的反馈到wilber上

Paste_Image.png

总结一下,当我们选用上面包车型地铁操作的时候,会生出浅拷贝的效劳:

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

首先区分一下可变对象和不可变对象:

总结

正文介绍了指标的赋值和拷贝,以及它们中间的分化:

  • Python中指标的赋值都以展开对象引用(内部存款和储蓄器地址)传递
  • 利用copy.copy(),能够拓展对象的浅拷贝,它复制了对象,但对于目的中的成分,如故采纳原有的引用.
  • 固然要求复制二个器皿对象,以及它里面包车型大巴富有因素(包涵成分的子成分),能够利用copy.deepcopy()进行深拷贝
  • 对此非容器类型(如数字、字符串、和别的’原子’类型的目的)没有被拷贝一说。
  • 如若元祖变量只含有原子类型对象,则无法深拷贝。

小编:田小布置
出处:http://www.cnblogs.com/wilber2013/

深拷贝

最后我们看看深拷贝

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变量,指向多少个list类型的靶子
  • 然后,通过copy模块里面的深拷贝函数deepcopy(),对will指向的目的举办深拷贝,然后深拷贝生成的新对象赋值给wilber变量

跟浅拷贝类似,深拷贝也会创建一个新的靶子,这一个例子中”wilber is not
will”
不过,对于目的中的成分,深拷贝都会再度生成一份(有异样情形,上边会表明),而不是粗略的采纳原始成分的引用(内部存储器地址)

事例中will的第八个要素指向287一九四三207496,而wilber的第七个元素是七个全新的靶子2871943341256,相当于说,”wilber[2]
is not will[2]”

  • 当对will举行修改的时候
    出于list的首先个因素是不可变类型,所以will对应的list的率先个要素会使用1个新的目的2871944496928

唯独list的第捌个元素是一个可变类型,修改操作不会发生新的对象,但是出于”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(),能够举行对象的浅拷贝,它复制了指标,但对此目的中的成分,照旧采取原来的引用.
  • 设若急需复制2个器皿对象,以及它个中的具备因素(包蕴成分的子成分),能够运用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])

实施代码,结果为:

美高梅开户网址 8

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

  • 第三,创设了3个名为will的变量,这一个变量指向1个list对象,从第二张图中能够见见有着目的的地址(每便运转,结果也许不相同)
  • 下一场,通过will变量对wilber变量举办赋值,那么wilber变量将对准will变量对应的目的(内部存款和储蓄器地址),也正是说”wilber
    is will”,”wilber[i] is
    will[i]”能够知道为,Python中,对象的赋值都以开始展览对象引用(内部存储器地址)传递
  • 其三张图中,由于will和wilber指向同贰个对象,所以对will的其余修改都会反映在wilber上那里须要专注的少数是,str是不足变类型,所以当修改的时候会交替旧的对象,爆发五个新的地方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])

履行代码,结果为:

美高梅开户网址 9

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

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

    • 浅拷贝会创立3个新的对象,这些例子中“wilber is not will”
    • 可是,对于指标中的元素,浅拷贝就只会动用原始成分的引用(内部存款和储蓄器地址),也正是说”wilber[i]
      is will[i]”
  • 当对will实行修改的时候

    • 是因为list的首先个因素是不可变类型,所以will对应的list的率先个要素会动用3个新的靶子2425789321544
    • 唯独list的第几个因素是三个可变类型,修改操作不会发出新的目的,所以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])

实践代码,结果为:

美高梅开户网址 10

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

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

    • 跟浅拷贝类似,深拷贝也会创设3个新的靶子,这一个事例中“wilber is
      not will”
    • 但是,对于指标中的成分,深拷贝都会再次生成一份(有独特别情报形,下边会表达),而不是粗略的施用原始元素的引用(内部存款和储蓄器地址)

      • 事例中will的第⑤个要素指向2822103840392,而wilber的第多少个成分是3个全新的靶子2822084461768,相当于说,“wilber[2]
        is not will[2]”
  • 当对will举办修改的时候

    • 由于list的首先个因素是不可变类型,所以will对应的list的率先个要素会利用二个新的靶子2822045929800
    • 可是list的第多少个成分是2个可不类型,修改操作不会发出新的目的,不过由于”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)
    

    美高梅开户网址 11

 

总结:

  • Python中目的的赋值都以展开对象引用(内部存款和储蓄器地址)传递
  • 使用copy.copy(),能够开始展览对象的浅拷贝,它复制了对象,但对于目的中的元素,依旧选用原有的引用.
  • 假使供给复制三个容器对象,以及它里面的兼具因素(包涵元素的子成分),能够使用copy.deepcopy()举办深拷贝
  • 对此非容器类型(如数字、字符串、和其它’原子’类型的靶子)没有被拷贝一说
  • 只要元祖变量只包罗原子类型对象,则不可能深拷贝。

参考资料:

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图