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]

 

 

 

代码的出口为:

 

 

 

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

 

率先,创设了1个名为will的变量,这几个变量指向多个list对象,从第三张图中得以看出有着指标的地方(每趟运转,结果也许差异)

接下来,通过will变量对wilber变量举行赋值,那么wilber变量将本着will变量对应的靶子(内部存储器地址),相当于说”wilber
is will”,”wilber[i] is will[i]”

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

其三张图中,由于will和wilber指向同三个指标,所以对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的率先个成分会利用3个新的靶子39758496

可是list的第多少个因素是一个可不类型,修改操作不会发生新的指标,所以will的改动结果会相应的反响到wilber上

python的浅拷贝和深拷贝,深拷贝和浅拷贝。 

 

小结一下,当我们选拔上边包车型客车操作的时候,会发生浅拷贝的功能:

 

利用切片[:]操作

采取工厂函数(如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变量,指向3个list类型的靶子

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

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

可是,对于指标中的成分,深拷贝都会重新生成一份(有异乎日常景况,上边会表明),而不是总结的施用原始成分的引用(内部存款和储蓄器地址)

事例中will的第多少个要素指向39737304,而wilber的第⑤个成分是一个全新的对象39773088,也正是说,”wilber[2]
is not will[2]”

当对will进行改动的时候

出于list的第3个元素是不足变类型,所以will对应的list的首先个因素会利用3个新的指标39758496

但是list的第一个要素是2个可不类型,修改操作不会发生新的靶子,不过由于”wilber[2]
is not will[2]”,所以will的改动不会潜移默化wilber

 

 

拷贝的独特别情报形

实在,对于拷贝有一部分优秀情状:

 

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

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

如若元祖变量只含有原子类型对象,则不能够深拷贝,看上面包车型客车事例

    

 

总结

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

 

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

采取copy.copy(),能够举办对象的浅拷贝,它复制了对象,但对此指标中的成分,仍然采纳原有的引用.

只要供给复制3个容器对象,以及它里面包车型大巴具备因素(包蕴成分的子成分),能够动用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

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

率先,创造了三个名为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

浅拷贝内部存储器分析

首先,依然选拔1个will变量,指向三个list类型的靶子
接下来,通过copy模块里面包车型的士浅拷贝函数copy(),对will指向的靶子开展浅拷贝,然后浅拷贝生成的新目的赋值给wilber变量
浅拷贝会创制三个新的对象,这几个事例中”wilber is not will”
只是,对于指标中的元素,浅拷贝就只会利用原始成分的引用(内部存款和储蓄器地址),也正是说”wilber[i]
is will[i]”
当对will举办修改的时候
鉴于list的首先个因素是不行变类型,所以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

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

首先,同样选择2个will变量,指向3个list类型的对象
下一场,通过copy模块里面包车型大巴深拷贝函数deepcopy(),对will指向的目的开始展览深拷贝,然后深拷贝生成的新对象赋值给wilber变量
跟浅拷贝类似,深拷贝也会创制3个新的靶子,那几个事例中”wilber is not
will”
只是,对于目的中的成分,深拷贝都会再也生成一份(有异样情况,上面会表达),而不是简不难单的选择原始成分的引用(内部存款和储蓄器地址)
事例中will的第多个因素指向39737304,而wilber的第四个要素是叁个崭新的指标39773088,也正是说,”wilber[2]
is not will[2]”
当对will实行改动的时候
鉴于list的首先个要素是不行变类型,所以will对应的list的第二个元素会利用2个新的靶子39758496
不过list的第多少个成分是3个可不类型,修改操作不会发生新的目的,但是由于”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的变量,那一个变量指向2个list对象,从第1张图中得以看看有着目的的地方(每趟运转,结果大概分裂)
  • 下一场,通过will变量对wilber变量举行赋值,那么wilber变量将对准will变量对应的靶子(内部存款和储蓄器地址),也正是说”wilber
    is will”,”wilber[i] is will[i]”

能够精晓为,Python中,对象的赋值皆以拓展对象引用(内存地址)传递

  • 其三张图中,由于will和wilber指向同贰个指标,所以对will的其余改动都会呈现在wilber上

此地需求专注的有些是,str是不可变类型,所以当修改的时候会交替旧的指标,爆发一个新的地址。

为了便利精通,小编将原版的书文的图样直接拷贝过来,里面内部存款和储蓄器地址编号和代码分化。

Paste_Image.png

那篇博客首要通过代码说Bellamy下指标赋值、浅拷贝和深拷贝三者的分别。

破例景况

实则,对于拷贝有局地与众分裂处境:
对于非容器类型(如数字、字符串、和其余’原子’类型的靶子)没有拷贝这一说
也正是说,对于这么些品种,”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变量

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

  • 当对will举行修改的时候
    鉴于list的率先个要素是不行变类型,所以will对应的list的第多少个成分会动用3个新的对象表示。
    只是list的第多个因素是1个可变类型,修改操作不会生出新的指标,所以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变量

跟浅拷贝类似,深拷贝也会创立1个新的指标,这么些例子中”wilber is not
will”
可是,对于指标中的成分,深拷贝都会另行生成一份(有例外意况,下边会说明),而不是简约的接纳原始成分的引用(内部存款和储蓄器地址)

事例中will的第13个要素指向287壹玖肆叁207496,而wilber的第13个成分是1个簇新的对象2871945341256,也正是说,”wilber[2]
is not will[2]”

  • 当对will进行改动的时候
    鉴于list的第二个因素是不可变类型,所以will对应的list的率先个要素会使用3个新的指标287一九四四496928

不过list的第7个成分是三个可变类型,修改操作不会时有产生新的对象,可是由于”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

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

  • 第贰,创设了三个名为will的变量,这几个变量指向2个list对象,从第壹张图中能够观望全体指标的地方(每一趟运营,结果可能两样)
  • 下一场,通过will变量对wilber变量实行赋值,那么wilber变量将对准will变量对应的靶子(内存地址),也便是说”wilber
    is will”,”wilber[i] is
    will[i]”能够知道为,Python中,对象的赋值都是展开对象引用(内部存储器地址)传递
  • 其三张图中,由于will和wilber指向同1个目的,所以对will的任何改动都会展现在wilber上那里须求留意的一点是,str是不行变类型,所以当修改的时候会交替旧的靶子,发生3个新的地点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

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

  • 第叁,依旧采纳2个will变量,指向3个list类型的靶子
  • 接下来,通过copy模块里面包车型客车浅拷贝函数copy(),对will指向的靶子实行浅拷贝,然后浅拷贝生成的新目的赋值给wilber变量

    • 浅拷贝会创设3个新的靶子,那一个事例中“wilber is not will”
    • 只是,对于指标中的成分,浅拷贝就只会使用原始成分的引用(内部存款和储蓄器地址),约等于说”wilber[i]
      is will[i]”
  • 当对will进行改动的时候

    • 是因为list的首先个要素是不行变类型,所以will对应的list的率先个成分会动用三个新的靶子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变量,指向1个list类型的对象
  • 然后,通过copy模块里面包车型客车深拷贝函数deepcopy(),对will指向的目的开始展览深拷贝,然后深拷贝生成的新目的赋值给wilber变量

    • 跟浅拷贝类似,深拷贝也会创设2个新的靶子,那个例子中“wilber is
      not will”
    • 只是,对于目的中的成分,深拷贝都会重复生成一份(有异乎常常景况,上面会表明),而不是大约的施用原始成分的引用(内部存款和储蓄器地址)

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

    • 是因为list的首先个因素是不行变类型,所以will对应的list的率先个要素会利用叁个新的靶子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地图