威尼斯人线上娱乐

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

29 3月 , 2019  

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的变量,这些变量指向1个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]

 

代码结果为:

 

 

 

解析一下那段代码:

 

第叁,依旧选拔3个will变量,指向二个list类型的靶子

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

浅拷贝会创制二个新的指标,那个例子中”wilber is not will”

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

当对will进行修改的时候

由于list的第①个成分是不足变类型,所以will对应的list的首先个因素会动用一个新的目的39758496

不过list的第多个要素是2个可不类型,修改操作不会时有产生新的对象,所以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变量

跟浅拷贝类似,深拷贝也会创建多个新的指标,这几个例子中”wilber is not will”

唯独,对于指标中的成分,深拷贝都会再次生成一份(有特殊意况,上边会表明),而不是简约的行使原始成分的引用(内部存款和储蓄器地址)

事例中will的第多个因素指向39737304,而wilber的第伍个要素是一个全新的靶子39773088,相当于说,”wilber[2]
is not will[深拷贝和浅拷贝,图解Python深拷贝和浅拷贝。2]”

当对will举办改动的时候

出于list的第3个成分是不可变类型,所以will对应的list的首先个要素会利用2个新的目的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]

代码的输出为:

威尼斯人线上娱乐 1

赋值拷贝

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

威尼斯人线上娱乐 2

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

率先,创造了1个名为will的变量,那一个变量指向贰个list对象,从第二张图中得以看来有着目的的地方(每一次运营,结果大概不一致)
下一场,通过will变量对wilber变量实行赋值,那么wilber变量将对准will变量对应的指标(内部存款和储蓄器地址),相当于说”wilber
is will”,”wilber[i] is will[i]”

能够驾驭为,Python中,对象的赋值都以拓展对象引用(内部存款和储蓄器地址)传递
其三张图中,由于will和wilber指向同一个指标,所以对will的任何修改都会显示在wilber上
此处要求注意的少数是,str是不足变类型,所以当修改的时候会交替旧的对象,产生二个新的地方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变量,指向三个list类型的靶子
然后,通过copy模块里面包车型地铁浅拷贝函数copy(),对will指向的目的开始展览浅拷贝,然后浅拷贝生成的新指标赋值给wilber变量
浅拷贝会创立一个新的目的,这些事例中”wilber is not will”
可是,对于目的中的成分,浅拷贝就只会动用原始成分的引用(内部存款和储蓄器地址),也正是说”wilber[i]
is will[i]”
当对will举办改动的时候
由于list的第1个成分是不可变类型,所以will对应的list的率先个要素会利用1个新的目的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

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

先是,同样选择二个will变量,指向三个list类型的对象
下一场,通过copy模块里面包车型地铁深拷贝函数deepcopy(),对will指向的目的开始展览深拷贝,然后深拷贝生成的新目的赋值给wilber变量
跟浅拷贝类似,深拷贝也会创制3个新的对象,那么些事例中”wilber is not
will”
只是,对于目的中的成分,深拷贝都会重新生成一份(有尤其处境,上面会表明),而不是差不多的施用原始成分的引用(内存地址)
事例中will的第多个成分指向39737304,而wilber的第三个因素是2个崭新的指标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]

咱俩解析下那段代码:

  • 先是,创设了3个名为will的变量,这么些变量指向2个list对象,从第3张图中得以看出有着目的的地点(每回运维,结果也许两样)
  • 下一场,通过will变量对wilber变量举行赋值,那么wilber变量将对准will变量对应的靶子(内部存款和储蓄器地址),也便是说”wilber
    is will”,”wilber[i] is will[i]”

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

  • 其三张图中,由于will和wilber指向同三个目的,所以对will的任何改动都会浮现在wilber上

此地供给小心的某些是,str是不足变类型,所以当修改的时候会交替旧的对象,发生贰个新的地址。

为了便利掌握,笔者将原来的书文的图样直接拷贝过来,里面内部存款和储蓄器地址编号和代码分裂。

Paste_Image.png

那篇博客首要通过代码说圣元(Synutra)(Beingmate)(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变量

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

  • 当对will举办修改的时候
    是因为list的率先个成分是不足变类型,所以will对应的list的首先个因素会利用贰个新的对象表示。
    可是list的第多个要素是3个可变类型,修改操作不会发生新的对象,所以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的第多个要素是3个崭新的目的2871944341256,也正是说,”wilber[2]
is not will[2]”

  • 当对will进行修改的时候
    出于list的第3个成分是不足变类型,所以will对应的list的首先个因素会动用二个新的指标287壹玖肆伍496928

唯独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(),能够开始展览对象的浅拷贝,它复制了指标,但对于目的中的成分,仍旧采用原有的引用.
  • 假如急需复制二个容器对象,以及它里面包车型大巴享有因素(包罗成分的子成分),可以应用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

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

  • 率先,创立了二个名为will的变量,那一个变量指向二个list对象,从第二张图中得以观望有着指标的地方(每一回运转,结果恐怕两样)
  • 然后,通过will变量对wilber变量进行赋值,那么wilber变量将针对will变量对应的对象(内部存款和储蓄器地址),也正是说”wilber
    is will”,”wilber[i] is
    will[i]”能够明白为,Python中,对象的赋值皆以拓展对象引用(内部存款和储蓄器地址)传递
  • 其三张图中,由于will和wilber指向同2个对象,所以对will的其余改动都会反映在wilber上那里需求注意的少数是,str是不可变类型,所以当修改的时候会交替旧的目的,爆发1个新的地址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

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

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

    • 浅拷贝会创造1个新的对象,那个事例中“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

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

  • 首先,同样运用2个will变量,指向3个list类型的靶子
  • 然后,通过copy模块里面包车型大巴深拷贝函数deepcopy(),对will指向的对象开展深拷贝,然后深拷贝生成的新对象赋值给wilber变量

    • 跟浅拷贝类似,深拷贝也会成立三个新的靶子,那么些事例中“wilber is
      not will”
    • 不过,对于目的中的成分,深拷贝都会再一次生成一份(有异样景况,上面会表明),而不是总结的运用原始成分的引用(内部存款和储蓄器地址)

      • 事例中will的第四个成分指向2822103840392,而wilber的第多少个因素是一个簇新的对象2822084461768,也正是说,“wilber[2]
        is not will[2]”
  • 当对will实行改动的时候

    • 出于list的率先个要素是不行变类型,所以will对应的list的第3个成分会使用七个新的对象2822045929800
    • 可是list的第一个要素是三个可不类型,修改操作不会发生新的靶子,不过出于”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(),能够拓展对象的浅拷贝,它复制了指标,但对于目的中的成分,如故采用原有的引用.
  • 比方急需复制1个器皿对象,以及它当中的全数因素(包括成分的子成分),能够选择copy.deepcopy()进行深拷贝
  • 对此非容器类型(如数字、字符串、和任何’原子’类型的靶子)没有被拷贝一说
  • 假若元祖变量只包罗原子类型对象,则无法深拷贝。

参考资料:

 


相关文章

发表评论

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

网站地图xml地图