浅复制python

1. python字典浅复制问题

这个情况跟你设计有关系的，dict1['1']应该是一个list，然后dict2['1']是另外一个list。如果前面的list跟后面的list不是一个，或者没有的关系的话，修改dict1['1']不会影响dict2['1']。
如果dict1['1'][0]是一个list，然后dict2['1'][0]也指向这个list的话，修改dict1['1'][0]，dict2['1'][0]也会跟着变化。

2. python的复制，深拷贝和浅拷贝的区别

在Python中存在深拷贝与浅拷贝的区别，相信有些Python初学者可能就有些疑惑，是指什么意思呢？
1. 赋值其实只是传递对象引用，引用对象id是一样的。
2. 浅拷贝是指拷贝的只是原始对象元素的引用，换句话说，浅拷贝产生的对象本身是新的，但是它的内容不是新的，只是对原对象的一个引用。
3. 深拷贝是指完全拷贝原始对象，而且产生的对象是新的，并且不受其他引用对象的操作影响。

3. python深拷贝和浅拷贝的区别

1、浅拷贝(shallow )

所谓“浅拷贝”，是指创建一个新的对象，其内容是原对象中元素的引用。(拷贝组合对象，不拷贝子对象)

常见的浅拷贝有：切片操作、工厂函数、对象的()方法、模块中的函数。

2、深拷贝(deep )

所谓“深拷贝”，是指创建一个新的对象，然后递归的拷贝原对象所包含的子对象。深拷贝出来的对象与原对象没有任何关联。

深拷贝只有一种方式：模块中的deep函数。

总结：

浅拷贝，没有拷贝子对象，所以原始数据改变，子对象会改变

深拷贝，包含对象里面的自对象的拷贝，所以原始对象的改变不会造成深拷贝里任何子元素的改变

4. Python3 浅层复制和深层复制有什么区别

浅复制对象指向同一个内存地址，深复制对象指向不同的内存地址。

5. python 为什么有深拷贝浅拷贝

在写Python过程中，经常会遇到对象的拷贝，如果不理解浅拷贝和深拷贝的概念，你的代码就可能出现一些问题。所以，在这里按个人的理解谈谈它们之间的区别。

一、赋值（assignment）
在《Python FAQ1》一文中，对赋值已经讲的很清楚了，关键要理解变量与对象的关系。

12345
>>> a = [1, 2, 3]>>> b = a>>> print(id(a), id(b), sep='\n')

在Python中，用一个变量给另一个变量赋值，其实就是给当前内存中的对象增加一个“标签”而已。
如上例，通过使用内置函数 id() ，可以看出 a 和 b 指向内存中同一个对象。a is b会返回 True 。

二、浅拷贝（shallow ）
注意：浅拷贝和深拷贝的不同仅仅是对组合对象来说，所谓的组合对象就是包含了其它对象的对象，如列表，类实例。而对于数字、字符串以及其它“原子”类型，没有拷贝一说，产生的都是原对象的引用。
所谓“浅拷贝”，是指创建一个新的对象，其内容是原对象中元素的引用。（拷贝组合对象，不拷贝子对象）
常见的浅拷贝有：切片操作、工厂函数、对象的()方法、模块中的函数。

12345678910
>>> a = [1, 2, 3]>>> b = list(a)>>> print(id(a), id(b)) # a和b身份不同140601785066200 140601784764968>>> for x, y in zip(a, b): # 但它们包含的子对象身份相同... print(id(x), id(y))... 140601911441984 140601911442048

从上面可以明显的看出来，a 浅拷贝得到 b，a 和 b 指向内存中不同的 list 对象，但它们的元素却指向相同的 int 对象。这就是浅拷贝！

三、深拷贝（deep ）
所谓“深拷贝”，是指创建一个新的对象，然后递归的拷贝原对象所包含的子对象。深拷贝出来的对象与原对象没有任何关联。
深拷贝只有一种方式：模块中的deep函数。
1234567891011
>>> import >>> a = [1, 2, 3]>>> b = .deep(a)>>> print(id(a), id(b))140601785065840 140601785066200>>> for x, y in zip(a, b):... print(id(x), id(y))... 140601911441984 140601911442048

看了上面的例子，有人可能会疑惑：
为什么使用了深拷贝，a和b中元素的id还是一样呢？
答：这是因为对于不可变对象，当需要一个新的对象时，python可能会返回已经存在的某个类型和值都一致的对象的引用。而且这种机制并不会影响 a 和 b 的相互独立性，因为当两个元素指向同一个不可变对象时，对其中一个赋值不会影响另外一个。
我们可以用一个包含可变对象的列表来确切地展示“浅拷贝”与“深拷贝”的区别：


>>> import >>> a = [[1, 2],[5, 6], [8, 9]]>>> b = .(a) # 浅拷贝得到b>>> c = .deep(a) # 深拷贝得到c>>> print(id(a), id(b)) # a 和 b 不同139832578518984 139832578335520>>> for x, y in zip(a, b): # a 和 b 的子对象相同... print(id(x), id(y))... 139832578622816 139832578623104>>> print(id(a), id(c)) # a 和 c 不同139832578518984 139832578622456>>> for x, y in zip(a, c): # a 和 c 的子对象也不同... print(id(x), id(y))... 139832578622816 139832578623392

从这个例子中可以清晰地看出浅拷贝与深拷贝地区别。

总结：
1、赋值：简单地拷贝对象的引用，两个对象的id相同。
2、浅拷贝：创建一个新的组合对象，这个新对象与原对象共享内存中的子对象。
3、深拷贝：创建一个新的组合对象，同时递归地拷贝所有子对象，新的组合对象与原对象没有任何关联。虽然实际上会共享不可变的子对象，但不影响它们的相互独立性。
浅拷贝和深拷贝的不同仅仅是对组合对象来说，所谓的组合对象就是包含了其它对象的对象，如列表，类实例。而对于数字、字符串以及其它“原子”类型，没有拷贝一说，产生的都是原对象的引用。

6. python字典浅复制问题

浅复制只复制对象内存，dict1的内存里放了两个引用list1和list2分别指向两个列表对象x和y，将dict1的内存复制到dict2中，于是dict2中也有两个引用list3和list4分别指向两个列表对象x和y。list1和list3指向同一个列表对象x，而list2和list4指向同一个列表对象y。通过list1去修改列表对象x的内容，再通过list3去访问，结果当然是一致变化的。

7. Python的复制，深拷贝和浅拷贝的区别

简单点说
1. . 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。
2. .deep 深拷贝 拷贝对象及其子对象
用一个简单的例子说明如下：
>>>import
>>>a = [1, 2, 3, 4, ['a', 'b', 'c']]
>>> b = a
>>> c = .(a)
>>> d = .deep(a)
很容易理解：a是一个列表，表内元素a[4]也是一个列表（也就是一个内部子对象）；b是对a列表的又一个引用，所以a、b是完全相同的，可以通过id(a)==id(b)证明。
第4行是浅拷贝，第五行是深拷贝，通过id(c)和id(d)可以发现他们不相同，且与id(a)都不相同：
>>> id(a)
19276104
>>> id(b)
19276104
>>> id(c)
19113304
>>> id(d)
19286976
至于如何看深/浅拷贝的区别，可以通过下面的操作来展现：
>>> a.append(5) #操作1
>>> a[4].append('hello') #操作2
这时再查看结果：
>>> a
[1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5]
>>> b
[1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5]
>>> c
[1, 2, 3, 4, ['a', 'b', 'c', 'hello']]
>>> d
[1, 2, 3, 4, ['a', 'b', 'c']]
可以发现a、b受了操作1、2的影响，c只受操作2影响，d不受影响。a、b结果相同很好理解。由于c是a的浅拷贝，只拷贝了父对象，因此a的子对象（ ['a', 'b', 'c', 'hello']）改变时会影响到c；d是深拷贝，完全不受a的影响

8. Python里面如何拷贝一个对象（赋值，浅拷贝，深拷贝的区别）

赋值(=)：就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。
浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用(如果用引用的方式修改其中一个对象，另外一个也会修改改变){1,完全切片方法;2，工厂函数，如list();3，模块的()函数}
深拷贝：创建一个新的对象，并且递归的复制它所包含的对象(修改其中一个，另外一个不会改变){模块的deep.deep()函数}

9. Python的列表有没有浅复制跟深复制的概念

有的。比如：

首先这里导入模块，并生成三个列表

发现list2和list3有不同，其中list2就是浅复制，list3就是深复制

浅复制就是指当对象的字段值被复制时，字段引用的对象不会被复制，也就是引用的对象和原数据还是同一个，并没有产生一个新的对象

深复制指对对象中字段引用的对象也进行复制的一种方式，会产生一个新的值相同的不同对象

10. 举例区分Python中的浅复制与深复制

举例区分Python中的浅复制与深复制
这篇文章主要介绍了举例区分Python中的浅复制与深复制,是Python入门学习中的重要知识,需要的朋友可以参考下
模块用于对象的拷贝操作。该模块非常简单，只提供了两个主要的方法： . 与 .deep ，分别表示浅复制与深复制。什么是浅复制，什么是深复制，网上有一卡车一卡车的资料，这里不作详细介绍。复制操作只对复合对象有效。用简单的例子来分别介绍这两个方法。
浅复制只复制对象本身，没有复制该对象所引用的对象。
#coding=gbk
import
l1 = [1, 2, [3, 4]]
l2 = .(l1)
print l1
print l2
l2[2][0] = 50
print l1
print l2
#---- 结果 ----
[1, 2, [3, 4]]
[1, 2, [3, 4]]
[1, 2, [50, 4]]
[1, 2, [50, 4]]

同样的代码，使用深复制，结果就不一样：
import
l1 = [1, 2, [3, 4]]
l2 = .deep(l1)
print l1
print l2
l2[2][0] = 50
print l1
print l2
#---- 结果 ----
[1, 2, [3, 4]]
[1, 2, [3, 4]]
[1, 2, [3, 4]]
[1, 2, [50, 4]]

改变的默认行为

在定义类的时候，通过定义____和__deep__方法，可以改变的默认行为。下面是一个简单的例子:
class CopyObj(object):
def __repr__(self):
return "CopyObj"

def ____(self):
return "Hello"
obj = CopyObj()
obj1 = .(obj)
print obj
print obj1
#---- 结果 ----
CopyObj
Hello