当前位置:   article > 正文

python中的赋值与深浅拷贝_python int深度拷贝

python int深度拷贝

在python中,只有在int和字符串,元组等不可变类型中,=与深浅拷贝的结果一样 ,因为其是不可变类型,都是连内存地址一起‘复制’了。而在list,dict,set中,深浅拷贝并没有复制‘地址’。‘复制’内存地址的结果就是,之后的操作会影响原来的对象。

以下所有的内容都是基于内存地址来说的。

  • 不可变数据类型: 当该数据类型的对应变量的值发生了改变,那么它对应的内存地址也会发生改变,对于这种数据类型,就称不可变数据类型。
  • 可变数据类型 :当该数据类型的对应变量的值发生了改变,那么它对应的内存地址不发生改变,对于这种数据类型,就称可变数据类型。

总结:不可变数据类型更改后地址发生改变,可变数据类型更改地址不发生改变

1.int型

  1. >>> import copy
  2. >>> a=1
  3. >>> b=a #赋值
  4. >>> c=copy.copy(a) #浅拷贝
  5. >>> d=copy.deepcopy(a)#深拷贝
  6. >>> print(id(a))
  7. 1473881184
  8. >>> print(id(b))
  9. 1473881184
  10. >>> print(id(c))
  11. 1473881184
  12. >>> print(id(d))
  13. 1473881184 #id地址都相等,所以深浅拷贝和赋值一样

 既然内存地址也复制的话,那就应该“牵一发而动全身”。让我们来试验下。

  1. >>> a=1
  2. >>> b=a
  3. >>> b=b+1
  4. >>> b
  5. 2
  6. >>> a
  7. 1

很奇怪,为什么这里复制了‘地址’,怎么结果还不一样呢?答案在这里。

  1. >>> a=1
  2. >>> b=a
  3. >>> id(b)
  4. 1473881184
  5. >>> b=b+1
  6. >>> id(b)
  7. 1473881216

 这是因为第二次b=b+1的时又给他分配了新的地址,字符串也一样。只有不可变类型例外,对其他的对象操作时,可以直接在分配好的内存地址上操作,而不会分配新的地址空间。

2.字符串

  1. >>> a='hello'
  2. >>> b=a
  3. >>> c=copy.copy(a)
  4. >>> d=copy.deepcopy(a)
  5. >>> print(id(a))
  6. 2723341052984
  7. >>> print(id(b))
  8. 2723341052984
  9. >>> print(id(c))
  10. 2723341052984
  11. >>> print(id(d))
  12. 2723341052984 #结果与int一样,三者相同

3.列表 (赋值是完全‘复制’,而深浅拷贝只是复制的值)

  1. >>> a=[1,2,3]
  2. >>> b=a
  3. >>> c=copy.copy(a)
  4. >>> d=copy.deepcopy(a)
  5. >>> print(id(a))
  6. 2723341059336
  7. >>> print(id(b))
  8. 2723341059336 #赋值把内存地址一起‘复制’了
  9. >>> print(id(c))
  10. 2723341059848 #内存地址与a不同
  11. >>> print(id(d))
  12. 2723341059592 #内存地址与a不同
  13. >>> print(a is b)
  14. True

让我们来检验下‘牵一发而动全身’的效果

  1. 赋值复制了内存地址,所以二者相同
  2. >>> a=[1,2,3]
  3. >>> b=a
  4. >>> b.append(1)
  5. >>> b
  6. [1, 2, 3, 1]
  7. >>> a
  8. [1, 2, 3, 1]
  1. 浅拷贝没有复制‘内存地址’,所以a不会变
  2. >>> a=[1,2,3]
  3. >>> c=copy.copy(a)
  4. >>> c.append(1)
  5. >>> c
  6. [1, 2, 3, 1]
  7. >>> a
  8. [1, 2, 3]

 

  1. 深拷贝同上
  2. >>> a=[1,2,3]
  3. >>> d=copy.deepcopy(a)
  4. >>> d.append(1)
  5. >>> a
  6. [1, 2, 3]
  7. >>> d
  8. [1, 2, 3, 1]

4.字典(与列表一样,只有赋值是完全‘复制’)

  1. >>> a={1:1,2:2}
  2. >>> b=a
  3. >>> c=copy.copy(a)
  4. >>> d=copy.deepcopy(a)
  5. >>> print(id(a))
  6. 2723338483752
  7. >>> print(id(b))
  8. 2723338483752
  9. >>> print(id(c))
  10. 2723338483824
  11. >>> print(id(d))
  12. 2723341076880
  13. >>> print(a is b)
  14. True
  1. >>> a={1:1}
  2. >>> d=copy.deepcopy(a)
  3. >>> d[2]=2
  4. >>> a
  5. {1: 1}
  6. >>> d
  7. {1: 1, 2: 2}
  8. >>> c=copy.copy(a)
  9. >>> c[3]=3
  10. >>> c
  11. {1: 1, 3: 3}
  12. >>> a
  13. {1: 1}

 

5.集合(与列表和字典一样。只有赋值是完全复制)

  1. >>> a=set([1,2,3])
  2. >>> b=a
  3. >>> c=copy.copy(a)
  4. >>> d=copy.deepcopy(a)
  5. >>> print(id(a))
  6. 2723341054472
  7. >>> print(id(b))
  8. 2723341054472
  9. >>> print(id(c))
  10. 2723341054696
  11. >>> print(id(d))
  12. 2723341055144
  13. >>> print(a is b)
  14. True

 

 

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/Monodyee/article/detail/71483
推荐阅读
相关标签
  

闽ICP备14008679号