Python 中的浅拷贝和深拷贝

1. 列表和字典,直接赋值,都是浅拷贝,即赋值双方指向同一地址,因为 Python 对可变对象按引用传递。

>>> a = [1, 2, 3]
>>> b = a
>>> b
[1, 2, 3]
>>> a[0] = ‘apple‘
>>> a
[‘apple‘, 2, 3]
>>> b
[‘apple‘, 2, 3]
>>>
>>>
>>> dic = {‘a‘: ‘apple‘, ‘b‘: ‘banbana‘}
>>> dic2 = dic
>>> dic2
{‘a‘: ‘apple‘, ‘b‘: ‘banbana‘}
>>> dic[‘b‘] = ‘blueberry‘
>>> dic
{‘a‘: ‘apple‘, ‘b‘: ‘blueberry‘}
>>> dic2
{‘a‘: ‘apple‘, ‘b‘: ‘blueberry‘}

2. 对非嵌套的列表,使用完全切片[:], 工厂函数 list(),或者 copy.copy() 都是深拷贝。

>>> a = [1, 2, 3]
>>> b = list(a)
>>> c = a[:]
>>> import copy
>>> d = copy.copy(a)
>>>
>>> a[0] = ‘apple‘
>>> a
[‘apple‘, 2, 3]
>>> b
[1, 2, 3]
>>> c
[1, 2, 3]
>>> d
[1, 2, 3]

3. 对于非嵌套的字典,使用工厂函数 dict(),或者 copy.copy() 都是深拷贝。

>>> dic = {‘a‘: ‘apple‘, ‘b‘: ‘banana‘}
>>> dic2 = dict(dic)
>>> import copy
>>> dic3 = copy.copy(dic)
>>>
>>> dic[‘b‘] = ‘blueberry‘
>>> dic
{‘a‘: ‘apple‘, ‘b‘: ‘blueberry‘}
>>> dic2
{‘a‘: ‘apple‘, ‘b‘: ‘banana‘}
>>> dic3
{‘a‘: ‘apple‘, ‘b‘: ‘banana‘}

4. 对于嵌套的列表,嵌套的字典,只能使用 copy.deepcopy() 实现深拷贝。

>>> import copy
>>>
>>> a = [1, 2, [‘apple‘]]
>>> b = copy.deepcopy(a)
>>> a[2][0] = ‘watermelon‘
>>> a
[1, 2, [‘watermelon‘]]
>>> b
[1, 2, [‘apple‘]]
>>>
>>>
>>> dic = {‘a‘: ‘apple‘, ‘b‘: {‘b1‘: ‘banana‘, ‘b2‘: ‘blueberry‘}}
>>> dic2 = copy.deepcopy(dic)
>>> dic[‘b‘][‘b1‘] = ‘bukeneng‘
>>> dic
{‘a‘: ‘apple‘, ‘b‘: {‘b1‘: ‘bukeneng‘, ‘b2‘: ‘blueberry‘}}
>>> dic2
{‘a‘: ‘apple‘, ‘b‘: {‘b1‘: ‘banana‘, ‘b2‘: ‘blueberry‘}}

5. 对于嵌套可变对象的元组,只有 copy.deepcopy() 实现深拷贝。

>>> import copy>>>
>>> t = (1, 2, [‘apple‘])
>>> t2 = t
>>> t3 = tuple(t)
>>> t4 = copy.copy(t)
>>> t5 = copy.deepcopy(t)
>>>
>>> t[2][0] = ‘watermelon‘
>>> t
(1, 2, [‘watermelon‘])
>>> t2
(1, 2, [‘watermelon‘])
>>> t3
(1, 2, [‘watermelon‘])
>>> t4
(1, 2, [‘watermelon‘])
>>> t5
(1, 2, [‘apple‘])

完。

时间: 2024-08-29 22:08:24

Python 中的浅拷贝和深拷贝的相关文章

Python中的浅拷贝与深拷贝

以下都是参考资料后,我自己的理解,如有错误希望大家不吝赐教. 大家有没有遇到这样一种情况,对象赋值后,对其中一个变量进行修改,另外一个变量的值也改变了.比如: person = ['name', ['saving', 100]] hubby = person wifey = person hubby[0] = 'joe' wifey[0] = 'jane' print hubby, wifey hubby[1][1] = 50 print hubby, wifey >>>['jane',

python中的浅拷贝和深拷贝

1.浅拷贝 copy.copy() 浅拷贝是拷贝只拷贝最外一层(这里所说的拷贝是重新生成一个内存地址,也就是只有最外层的地址是重新生成) import copy li=[23,45,['wew',35,[33,00]]] li1=copy.copy(li) print(id(li),id(li1)) print(id(li[0]),id(li1[0])) print(id(li[2][1]),id(li1[2][1])) #输出:35540704 5872576 # 1625084720 162

Python中的赋值、深拷贝与浅拷贝(内存地址)

1.python中的可变对象与不可变对象 (1) 可变对象:dict,list def dict_test(): a = {} b = a print(id(a)) # 140367329543360 a['a'] = 'hhhh' print('id a:' + str(id(a))) # id a:140367329543360 print('a:' + str(a)) # a:{'a': 'hhhh'} print('id b:' + str(id(b))) # id b:14036732

Python——赋值、浅拷贝、深拷贝

和很多语言一样,Python中也分为简单赋值.浅拷贝.深拷贝这几种“拷贝”方式. 在学习过程中,一开始对浅拷贝理解很模糊.不过经过一系列的实验后,我发现对这三者的概念有了进一步的了解. 一.赋值 赋值算是这三种操作中最常见的了,我们通过一些例子来分析下赋值操作: str例 >>> a = 'hello' >>> b = 'hello' >>> c = a >>> [id(x) for x in a,b,c] [4404120000,

Python赋值、浅拷贝、深拷贝

一.赋值(assignment) >>> a = [1, 2, 3] >>> b = a >>> print(id(a), id(b), sep='\n') 139701469405552 139701469405552 在Python中,用一个变量给另一个变量赋值,其实就是给当前内存中的对象增加一个"标签"而已. 如上例,通过使用内置函数 id() ,可以看出 a 和 b 指向内存中同一个对象.a is b会返回 True . 二

Python 赋值、浅拷贝和深拷贝

初学Python,和C++还是有许多不同.直接赋值.浅拷贝和深拷贝,这三种拷贝对象的操作之间还是有许多的区别.Python语言的版本为2.7,在Pycharm中进行实验. 一.直接赋值 用下面的代码来实验: 1 origin = [1, "string", [1, 3, 5]] 2 Copy = origin 3 print Copy 4 print id(origin), id(Copy) 5 Copy[0] = 5 6 print origin, Copy 7 Copy[1] =

Javascript中的浅拷贝和深拷贝

很多开发语言中都有浅拷贝和深拷贝的说法,这里简单区分一下它们在Javascript中的区别,以及jQuery中深拷贝的实现. 在谈浅拷贝和深拷贝之前,先要屡清楚Javascript中的按值访问和按引用访问这两个概念. 按值访问是针对基本类型(string.number.boolean.null.undefined).基本类型以值的形式被存放在栈内存中,我们通过变量操作的是栈内存中实际的值. 按引用访问时针对引用类型(Object.Array.Date.RegExp.Function).引用类型以

C#中的浅拷贝和深拷贝

#中有两种类型变量,一种是值类型变量,一种是引用类型变量. 对于前者,copy是属于全盘复制:而对于后者,一般的copy只是浅copy,只copy引用地址,相当于只传递一个引用指针一样.因此对于后者进行真正copy的时候,也是最费事的,具体的说,必须为其实现 ICloneable接口中提供的Clone方法,从而产生一个全新的对象. 浅拷贝(影子克隆):只复制对象的基本类型,对象类型,仍属于原来的引用. 深拷贝(深度克隆):不紧复制对象的基本类,同时也复制原对象中的对象.就是说完全是新对象产生的.

浅谈JS中的浅拷贝与深拷贝

前端工程师应该都比较熟悉浅拷贝和深拷贝的概念,在日常业务代码的过程中,特别是做数据处理的时候,经常行的会遇到,比如如何在不修改原对象的基础上,重新生成一个一模一样的对象,加以利用,又或是,如何巧妙地运用相关的内置API,来达成自己所需要的结果,比如数组相关的操作,splice和slice就是截然相反的处理,虽然同样是对数组进行截取操作,但是前者会影响原数组,后者则是返回一个新的数组对象,而对原来的数组并不会产生任何影响,这其中的差别,需要有一定的开发经验才能明白. 好了,废话也不多说,下面来简单