Python中变量赋值,浅复制,深复制后，变量id的变化

最新推荐文章于 2024-06-20 10:35:48 发布
最新推荐文章于 2024-06-20 10:35:48 发布
阅读量1.1k 收藏 4
点赞数 1
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46437313/article/details/123613968
版权

先说结论,以vscode测试为准因为自己验证vscode和cmd命令行运行的结果有差异：

  1. 不可变对象,数值,字符串,元组(元素也为不可变),其同样值赋值给两个变量,浅复制,深复制,其变量id一致
  2. 可变对象,列表,字典,集合,元组(元素有可变对象),其同样赋值给两个变量,浅复制,深复制,其变量id不一致
import copy
print('-'*20+'数值型'+'-'*20)
a=10
b=10
c=copy.copy(a)
d=copy.deepcopy(a)
print('a和b通过=赋值后为:{},验证a和b的id是否一致:{}'.format(a,a is b))
print('c通过浅拷贝a后值为:{},验证a和c的id是否一致:{}'.format(c,c is a))
print('c通过深拷贝a后值为:{},验证a和d的id是否一致:{}'.format(d,d is a))
a=-1000000000
b=-1000000000
c=copy.copy(a)
d=copy.deepcopy(a)
print('a和b通过=赋值后为:{},验证a和b的id是否一致:{}'.format(a,a is b))
print('c通过浅拷贝a后值为:{},验证a和c的id是否一致:{}'.format(c,c is a))
print('c通过深拷贝a后值为:{},验证a和d的id是否一致:{}'.format(d,d is a))
a=10000000000
b=10000000000
c=copy.copy(a)
d=copy.deepcopy(a)
print('a和b通过=赋值后为:{},验证a和b的id是否一致:{}'.format(a,a is b))
print('c通过浅拷贝a后值为:{},验证a和c的id是否一致:{}'.format(c,c is a))
print('c通过深拷贝a后值为:{},验证a和d的id是否一致:{}'.format(d,d is a))
print('-'*20+'字符串型'+'-'*20)
a='jacky'
b='jacky'
c=copy.copy(a)
d=copy.deepcopy(a)
print('a和b通过=赋值后为:{},验证a和b的id是否一致:{}'.format(a,a is b))
print('c通过浅拷贝a后值为:{},验证a和c的id是否一致:{}'.format(c,c is a))
print('c通过深拷贝a后值为:{},验证a和d的id是否一致:{}'.format(d,d is a))
a='jacky_123'
b='jacky_123'
c=copy.copy(a)
d=copy.deepcopy(a)
print('a和b通过=赋值后为:{},验证a和b的id是否一致:{}'.format(a,a is b))
print('c通过浅拷贝a后值为:{},验证a和c的id是否一致:{}'.format(c,c is a))
print('c通过深拷贝a后值为:{},验证a和d的id是否一致:{}'.format(d,d is a))
a='jacky$123'
b='jacky$123'
c=copy.copy(a)
d=copy.deepcopy(a)
print('a和b通过=赋值后为:{},验证a和b的id是否一致:{}'.format(a,a is b))
print('c通过浅拷贝a后值为:{},验证a和c的id是否一致:{}'.format(c,c is a))
print('c通过深拷贝a后值为:{},验证a和d的id是否一致:{}'.format(d,d is a))
print('-'*20+'元组型'+'-'*20)
a=(1,2,3,)
b=(1,2,3)
c=copy.copy(a)
d=copy.deepcopy(a)
print('a和b通过=赋值后为:{},验证a和b的id是否一致:{}'.format(a,a is b))#T
print('c通过浅拷贝a后值为:{},验证a和c的id是否一致:{}'.format(c,c is a))#T
print('c通过深拷贝a后值为:{},验证a和d的id是否一致:{}'.format(d,d is a))#T
a=(1,2,3,[1,2,3])#不可变的元组里面有可变元素
b=(1,2,3)
c=copy.copy(a)
d=copy.deepcopy(a)
print('a和b通过=赋值后为:{},验证a和b的id是否一致:{}'.format(a,a is b))#F
print('c通过浅拷贝a后值为:{},验证a和c的id是否一致:{}'.format(c,c is a))#T
print('c通过深拷贝a后值为:{},验证a和d的id是否一致:{}'.format(d,d is a))#F
print('-'*20+'列表型'+'-'*20)
a=[1,2,3]
b=[1,2,3]
c=copy.copy(a)
d=copy.deepcopy(a)
print('a和b通过=赋值后为:{},验证a和b的id是否一致:{}'.format(a,a is b))
print('c通过浅拷贝a后值为:{},验证a和c的id是否一致:{}'.format(c,c is a))
print('c通过深拷贝a后值为:{},验证a和d的id是否一致:{}'.format(d,d is a))
print('-'*20+'字典型'+'-'*20)
a={'name':'jacky'}
b={'name':'jacky'}
c=copy.copy(a)
d=copy.deepcopy(a)
print('a和b通过=赋值后为:{},验证a和b的id是否一致:{}'.format(a,a is b))
print('c通过浅拷贝a后值为:{},验证a和c的id是否一致:{}'.format(c,c is a))
print('c通过深拷贝a后值为:{},验证a和d的id是否一致:{}'.format(d,d is a))
print('-'*20+'集合型'+'-'*20)
a={'name'}
b={'name'}
c=copy.copy(a)
d=copy.deepcopy(a)
print('a和b通过=赋值后为:{},验证a和b的id是否一致:{}'.format(a,a is b))#F
print('c通过浅拷贝a后值为:{},验证a和c的id是否一致:{}'.format(c,c is a))#F
print('c通过深拷贝a后值为:{},验证a和d的id是否一致:{}'.format(d,d is a))#F

'''
--------------------数值型--------------------
a和b通过=赋值后为:10,验证a和b的id是否一致:True
c通过浅拷贝a后值为:10,验证a和c的id是否一致:True
c通过深拷贝a后值为:10,验证a和d的id是否一致:True
a和b通过=赋值后为:-1000000000,验证a和b的id是否一致:True
c通过浅拷贝a后值为:-1000000000,验证a和c的id是否一致:True
c通过深拷贝a后值为:-1000000000,验证a和d的id是否一致:True
a和b通过=赋值后为:10000000000,验证a和b的id是否一致:True
c通过浅拷贝a后值为:10000000000,验证a和c的id是否一致:True
c通过深拷贝a后值为:10000000000,验证a和d的id是否一致:True
--------------------字符串型--------------------
a和b通过=赋值后为:jacky,验证a和b的id是否一致:True
c通过浅拷贝a后值为:jacky,验证a和c的id是否一致:True
c通过深拷贝a后值为:jacky,验证a和d的id是否一致:True
a和b通过=赋值后为:jacky_123,验证a和b的id是否一致:True
c通过浅拷贝a后值为:jacky_123,验证a和c的id是否一致:True
c通过深拷贝a后值为:jacky_123,验证a和d的id是否一致:True
a和b通过=赋值后为:jacky$123,验证a和b的id是否一致:True
c通过浅拷贝a后值为:jacky$123,验证a和c的id是否一致:True
c通过深拷贝a后值为:jacky$123,验证a和d的id是否一致:True
--------------------元组型--------------------
a和b通过=赋值后为:(1, 2, 3),验证a和b的id是否一致:True
c通过浅拷贝a后值为:(1, 2, 3),验证a和c的id是否一致:True
c通过深拷贝a后值为:(1, 2, 3),验证a和d的id是否一致:True
a和b通过=赋值后为:(1, 2, 3, [1, 2, 3]),验证a和b的id是否一致:False
c通过浅拷贝a后值为:(1, 2, 3, [1, 2, 3]),验证a和c的id是否一致:True
c通过深拷贝a后值为:(1, 2, 3, [1, 2, 3]),验证a和d的id是否一致:False
--------------------列表型--------------------
a和b通过=赋值后为:[1, 2, 3],验证a和b的id是否一致:False
c通过浅拷贝a后值为:[1, 2, 3],验证a和c的id是否一致:False
c通过深拷贝a后值为:[1, 2, 3],验证a和d的id是否一致:False
--------------------字典型--------------------
a和b通过=赋值后为:{'name': 'jacky'},验证a和b的id是否一致:False
c通过浅拷贝a后值为:{'name': 'jacky'},验证a和c的id是否一致:False
c通过深拷贝a后值为:{'name': 'jacky'},验证a和d的id是否一致:False
--------------------集合型--------------------
a和b通过=赋值后为:{'name'},验证a和b的id是否一致:False
c通过浅拷贝a后值为:{'name'},验证a和c的id是否一致:False
c通过深拷贝a后值为:{'name'},验证a和d的id是否一致:False
'''
weixin_46437313
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
详解Python列表赋值复制深拷贝及5种浅拷贝
09-19
对于初学者而言，理解列表的赋值、复制、深拷贝与浅拷贝之间的区别至关重要。本篇文章将深入探讨这些概念，并通过具体示例帮助读者更好地掌握。 #### 列表赋值 在Python中，当我们将一个列表赋值给另一个变量时，...
【Python入门学习】详谈python变量和变量赋值语句
12-21
本篇文章将详细探讨Python中的变量和变量赋值语句。 首先，让我们来看一下变量的命名规则。在Python中，变量名必须遵循一定的规范，以确保代码的可读性和正确性。变量名可以由字母（包括英文和非英文字符）、数字...
Python中类型的可变和不可变、变量赋值浅复制深复制后变量id的变化、小整数、拆包应用交换两个变量的值和Python中几种输出方式
Redamancy06的博客
06-27 733
类型的可变与不可变: 在不改变变量引用的前提下,能否改变变量中引用中的数据,如果能改变是可变类型, 如果不能改变,是不可变类型 int float bool str list tuple dict 不可变类型: int float bool str tuple（一部分） 可变类型: list dict tuple（一部分） 二、变量赋值浅复制深复制后变量id的变化 1.不可变对象,数值,字符串,元组(元素没有可变对象),其同样值赋值给两个变量,浅复制,深复制,其变量id一致 2.可变对象,列表,字典,集
python浅拷贝不改变id 地址
ｚ先生的博客
08-26 345
主要想知道 为啥 浅拷贝对不可变数据类型 不改变id 地址 上代码 def copy(x): """Shallow copy operation on arbitrary Python objects. See the module's __doc__ string for more info. """ cls = type(x) copier = _copy_dispatch.get(cls) print(_copy_dispatch) if
在Python语言中，当我们为一个变量赋一个新值时，旧变量会发生什么情况？
最新发布
wangbadan121的专栏
06-20 388
在这个例子中，我们首先定义了一个名为`a`的变量，并给它赋值为整数10。然后，我们将这个变量的值改为字符串"你好"，这导致了`a`变量的类型从整数变为字符串，原来的值为10的整数被覆盖了。最后，尝试再次访问这个变量的值时，由于它的新类型是字符串，所以出现了类型错误。这意味着，如果之前已经有一个与这个新值相同或可以转换为这个新值的变量，那么旧变量将不再存在，它的内存空间将被释放，存储的新值将会成为新的变量。a = "你好" # A 现在是一个字符串，值为"你好"# 将变量a的值改为字符串"你好"
python--类－实例－继承中变量的id是否变化
云金杞
11-09 654
''' 注：　估计这么乱的代码只有我自己能看。通过这段代码的验证，证明了在类和实例的相对关系中， 把变量保存为字符串，数字，在各个类、实例之间变换的时候，变量的id是变化的， 把变量保存为列表和字典的时候,id地址是不变的。id地址变与不变用于确认是否是同一份数据， 看一下这个变量是否是全局变量 ''' class InitParam(object): def __init__(self...
Pyhton的浅拷贝copy应用、可变变量的内存地址指向（id）
Buaixiao的博客
06-15 238
Pyhton的浅拷贝copy应用、可变变量的内存地址指向（id）
python中变量的值和类型为什么都可以变化_为什么在python中变量的地址在被赋予不同值时会发生变化？...
weixin_34234741的博客
01-29 413
您的基本误解是id属于Python对象，而不是变量。因此，任何对新对象的重新分配都会导致id的更改：>>> x = (1,2)>>> hex(id(x))'0x107526e48'>>> x = (2, 4)>>> hex(id(x))'0x107526e88'请注意，每次创建新对象时，都会发生以下情况：^{pr2}$不变性或...
深入理解Python中变量赋值的问题
12-25
Python是动态类型语言，也就是说不需要预先声明变量类型，变量的类型和值在赋值那一刻被初始化，下面详细介绍了Python的变量赋值问题，一起来学习学习吧。 我们先看一下如下代码: c = {} def foo(): f = dict(zip...
Python中实现变量赋值传递时的引用和拷贝方法
12-23
曾经看到这样一个问题，一个字典中的元素是列表，将这个列表元素赋值给一个变量，然后修改这个列表中元素的值，结果发现，字典中那个列表也同样修改了。 那个问题如下： dict = {'a':[1,2,3,4,5],'b':2} x = dict['...
python中的id_python中id与赋值的疑惑？
weixin_39752352的博客
12-11 710
这个涉及到Python的变量定义，以及垃圾回收机制首先说明一点，Python的内建函数id()返回的其实是变量的内存地址1、先看一下题主的代码c = []#这里定义了一个新的变量[]，给它分配了内存空间，如题是82482056，c作为一个名称指向内存空间82482056d = []#这里定义了一个新的变量[]，给它分配了内存空间，如题是82452296，d作为一个名称指向内存空间82452296e...
数值的加减会改变python中id_为什么对象的id会根据python shell中的行而改变
weixin_39964573的博客
12-09 121
This questions is just out of curiosity.While I was reading the python's object model documentation, I decided to experiment a little with the id of a class method and found this behavior:Python 3.2....
python函数内部的变量的id地址变与不变
conchincradle的博客
04-04 720
def g_append(value, a = None): #if a is None: a = [] print(id(a)) #a = [] a.append(value) return a g_append(1) g_append(2) output： 2736902920768 2736902920768 def g_append(value, a = None): #if a is None: ...
python3纵向输出字符串_Python3基础 tuple 使用格式化字符串进行输出
weixin_39770165的博客
12-05 186
Python : 3.7.3OS : Ubuntu 18.04.2 LTSIDE : pycharm-community-2019.1.3Conda : 4.7.5typesetting : Markdowncodecoder@ubuntu:~$ source activate py37(py37) coder@ubuntu:~$ ipythonPython 3.7.3 (default, Mar...
5、浅拷贝与深拷贝
weixin_45065754的博客
04-03 702
1、总结 浅拷贝和深拷贝都是用于对象拷贝的，区别在于浅拷贝是复制对象地址的，只要数据改变，原对象数据会跟着改变；而深拷贝是复制数据，再新建一个地址，数据改变不会影响原对象的数据，深拷贝有两种方法，一种是JSON转换，另一种是用递归方法复制对象数据，推荐用JSON转换，方便快捷，就是这么简单。 2、浅拷贝 拷贝的是地址，修改拷贝后的数据对原对象有影响 <script> /* 1、浅拷贝：拷贝的是地址，修改拷贝后的数据对原对象有影响 2、深拷贝：拷贝的是数据，修改拷贝后的数据对原对象
Python中的赋值机制
qq_41819196的博客
09-20 527
Python中的赋值机制 这一章比较短，我们谈一下Python中的赋值机制 Python中的赋值是通过地址（id）指向值的,我们可以用id（）来获取该变量指向的地址值 看下面的代码 a = 1000 b = a print(id(a)) print(id(b)) 运行结果： 82675088 82675088 两个变量的id是一样的，说明两个变量a,b所指向的地址是一样的 同样看，下面的代码： a = 1000 b = 1000 print(id(a)) print(id(b)) 运行结果： 8267
Python深拷贝和浅拷贝的区别
weixin_43661378的博客
08-11 305
浅拷贝只会使列表的id地址发生改变，则一个列表的变化不会影响另一个列表的变化，但是子列表的id并没有被改变，因此，子列表的值会随着一个列表的变化而变化。 深拷贝会使列表的id地址发生改变，则一个列表的变化会影响另一个列表的变化，而且子列表的id也会被改变，因此，一个列表的子列表中值的变化，并不会影响另一个列表的子列表。 通过如下代码可以充分反映深拷贝和浅拷贝的区别，以及引用的区别。 ''' ---** coding by utf-8 **--- 作者：hui 时间：2020年-08月-11日 ''' imp
深拷贝和浅拷贝，以及深拷贝的实现，深拷贝和浅拷贝的区别
weixin_52280029的博客
05-20 247
1.对于基本数据类型，严格意义上来说是赋值 let a = 5; let b = a; b = 3; console.log(a, b); 2.对于数组和对象的赋值都叫做浅拷贝 let arr = [1, 2, 3]; let newArr = arr; newArr.push(4) //改变了newArr原数组也的到了改变 console.log(newArr); //1,2,3,4 console.log(ar
python运算符——赋值运算符
qq_52788787的博客
03-14 787
i=3+4 a=b=c=10 print(a,id(a)) print(b,id(b)) print(c,id(c)) print(a is b is c) a+=30 #a=1+30 b-=10 #b=b-10 c*=3 #c=c*3 a/=3 #a=a/3 b//=3 #b=b//3 c%=3 #c=c%3 #解包赋值 a,b,c=10,20,30 print(a,b,c) 上述代码中有一段print（a is b is c），运行.
python的变量赋值操作_Python编程之变量赋值操作实例分析
06-03
Python中的变量赋值操作非常简单，只需要使用等号“=”即可。例如，将数字10赋值给变量x，可以写成： ```python x = 10 ``` 同样的，将字符串"hello"赋值给变量y，可以写成： ```python y = "hello" ``` 变量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值