What gets printed?()
kvps = { '1' : 1, '2' : 2 }
theCopy = kvps.copy()
kvps['1'] = 5
sum = kvps['1'] + theCopy['1']
print sum
[单选题]
ruiruisun
kvps.copy(),相当于复制一份，原来的改变不影响复制后的，理解为独立的
import copy
theqian = copy.copy(kvps),这个是真正的浅拷贝，kvps内部对象变，theqian也会跟着变，kvps指向其它对象，theqian不变。
例如：
>>> import copy
>>> origin = [1, 2, [3, 4]] #origin 里边有三个元素：1， 2，[3, 4]
>>> cop1 = copy.copy(origin)
>>> origin[2][0] = "hey!"
>>> origin
[1, 2, ['hey!', 4]]
>>> cop1
[1, 2, ['hey!', 4]]
theshen = copy.deepcopy(kvps),这个是真正的深拷贝，kvps怎么变，theshen不变。
总结。
a = object.copy() 等价于 b = copy.deepcopy(object),a和b一样
copy.copy(object)是浅拷贝，相当于变量引用,等同于下面代码。
a = [1,2,3]
b = a
a = [4,5,6]
>>>b
[1,2,3]
c = b
b[0] = 20
>>>c
[20,2,3]
编辑于 2018-05-07 16:59:49
回复(17)
1、b = a: 赋值引用，a 和 b 都指向同一个对象。
2、b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。
b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。
发表于 2018-08-12 09:21:43
回复(13)
这里的 kvps.copy()指的是浅拷贝，kvps['1'] 和theCopy['1']原本指向的都是1，但是因为int是不可变的的，所以kvps['1']=5，使得kvps['1']更改指向了，但是theCopy指向的1是int，本身没有改变也不能改变，所以还是1。
发表于 2019-05-09 21:53:27
回复(10)
本题考查的是 dict 类型中 copy() 方法的使用，正确答案应选 C。
首先来吐槽一下排版，不然直接报语法错误，免得有的人一上来就选 E。
kvps = { '1' : 1, '2' : 2 }
theCopy = kvps.copy()
kvps['1'] = 5
sum = kvps['1'] + theCopy['1']
print sum
在 Python2 和 Python3 中，copy() 方法的意义相同，均为返回一个浅复制的 dict 对象，而浅复制是指只拷贝父对象，不会拷贝对象的内部的子对象，即两个 dict 父对象 kvps 与 theCopy 相互独立，但对它们内部子对象的引用却是共享的，所以 kvps['1'] 的改变不影响 theCopy['1'] 的值（因为改变的是父对象的值）。
顺便一提，深复制是指完全拷贝父对象与子对象，即都相互独立。
注意，这里的子对象不是子类的对象，而是在父对象中的二级对象。
详情可参考：
发表于 2018-01-12 17:03:13
回复(6)
import copy d = {'1': [1, 1, 1], '2': 2} copy1 = d copy2 = d.copy() copy3 = copy.copy(d) copy4 = copy.deepcopy(d) d['1'][0] = 3 d['2'] = 3 print(copy1, copy2, copy3, copy4)打印结果分比为
{'1': [3, 1, 1], '2': 3}
{'1': [3, 1, 1], '2': 2}
{'1': [3, 1, 1], '2': 2}
{'1': [1, 1, 1], '2': 2}
方法1：赋值引用，copy1和d指向同一个对象
方法2：浅复制，复制生成新对象copy2，但是只复制一层，[1, 1, 1]为两者共同子对象，
方法3：浅复制，调用copy模块中的方法，同方法2
方法3：深复制，复制生成新对象copy4，并且递归复制所有子对象，所以d中原来指向[1, 1, 1]的改动不会影响深复制生成的子对象[1, 1, 1]
发表于 2019-01-23 16:16:08
回复(4)
a = {'1':1,'2':2,'3':[1,2],4:'abc'}
b = a.copy()和b=copy.copy(a)都属于浅拷贝
当a/b中的不可改变数据：int类型、string类型、tuple类型发生改变时候，不影响到另一个。
但其它的情况下，如更改列表元素，会发生互相影响。
举例：
①不可变数据改变举例
对int改变：
a = {'1':1,'2':2,'3':[1,2],'4':'abc'}
b = a.copy()
a['1']=250
print(a)
print(b)
out:
b = a.copy()
a['1']=250
print(a)
print(b)
out:
{'1': 250, '2': 2, '3': [1, 2], '4': 'abc'}
{'1': 1, '2': 2, '3': [1, 2], 4: 'abc'} 对string改变：
a = {'1':1,'2':2,'3':[1,2],'4':'abc'}
b = a.copy()
a['4']='def'
print(a)
print(b)
out:
b = a.copy()
a['4']='def'
print(a)
print(b)
out:
{'1': 1, '2': 2, '3': [1, 2], '4': 'def'}
{'1': 1, '2': 2, '3': [1, 2], '4': 'abc'} 对tuple改变：
a = {'1':1,'2':2,'3':[1,2],'4':'abc'}
b = a.copy()
a['3']=[1,2,3]
print(a)
print(b)
b = a.copy()
a['3']=[1,2,3]
print(a)
print(b)
{'1': 1, '2': 2, '3': [1, 2, 3], '4': 'abc'}
{'1': 1, '2': 2, '3': [1, 2], '4': 'abc'} ②可变数据改变举例
a = {'1':1,'2':2,'3':[1,2],'4':'abc'}
b = a.copy()
a['3'][0]=2
print(a)
print(b)
b = a.copy()
a['3'][0]=2
print(a)
print(b)
{'1': 1, '2': 2, '3': [2, 2], '4': 'abc'}
{'1': 1, '2': 2, '3': [2, 2], '4': 'abc'}
发表于 2022-03-10 20:57:32
回复(1)
# dict.copy : Return a shallow copy of the dictionary.
# for example,
In [1]: dict1 = {1:1, 2:[2,4]}
In [2]: dict_copy = dict1.copy()
In [3]: dict1[2][0] = 3
In [4]: dict_copy
Out[5]: {1: 1, 2: [3, 4]}
In [6]: dict1[1] = 0
In [7]: dict_copy
Out[8]: {1: 1, 2: [3, 4]}
发表于 2018-08-01 19:49:30
回复(0)
import copy
c0 = { '1' : 1 , 1 : [1,2]}
c1 = c0
c2 = copy.copy(c0)
c3 = copy.deepcopy(c0)
c4 = c0.copy() #返回一个浅拷贝
c0['1'] = 5
c0['4'] = 1
c0[1].append(4)
print("c0",c0) #c0 {'1': 5, 1: [1, 2, 4], '4': 1}
print("c1",c1) #c1 {'1': 5, 1: [1, 2, 4], '4': 1}
print("c2",c2) #c2 {'1': 1, 1: [1, 2, 4]}
print("c3",c3) #c3 {'1': 1, 1: [1, 2]}
print("c4",c4) #c4 {'1': 1, 1: [1, 2, 4]}
发表于 2019-05-07 15:54:30
回复(0)
浅拷贝： 拷贝的是对象的引用，原数据改变时，拷贝数据也发生改变。但是变不变要看修改的那个数据是不是可变的，例如int就是不可变的，list就是可变的，truple是不可变的（切片，赋值，调用copy模块的copy方法）
深拷贝： 拷贝的是对象的元素，原数据改变时，拷贝数据不发生改变。没有关系，是两个独立的对象（用copy模块的deepcopy方法）
发表于 2022-03-09 23:42:55
回复(0)
kvps ={ '1': 1, '2': 2}
theCopy =kvps.copy() # 浅拷贝，但是拷贝最顶端一层，所以theCopy = { '1': 1, '2': 2}
kvps['1'] =5 # 而kvpskvps['1'] =5影响不到浅拷贝copy的最顶端一层，所以kvps['1'] =5 ，而theCopy['1']=1
sum=kvps['1'] +theCopy['1']
printsum
发表于 2020-01-15 23:04:51
回复(0)
注意区分概念
浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
两者的区别在于对‘对象的拷贝’，对数值则拷贝后完全是独立的。因此改变dict中普通数值，浅拷贝与深拷贝结果相同。另一个copy对象并不会跟着改变（本题的情况）。
#!/usr/bin/python # -*-coding:utf-8 -*-
import copy a = [1, 2, 3, 4, ['a', 'b']] #原始对象
b = a #赋值，传对象的引用
c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝
a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象
print( 'a = ', a )
print( 'b = ', b )
print( 'c = ', c )
print( 'd = ', d )
输出：
('a = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5]) ('b = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5]) ('c = ', [1, 2, 3, 4, ['a', 'b', 'c']]) ('d = ', [1, 2, 3, 4, ['a', 'b']])
编辑于 2018-09-10 15:02:39
回复(0)
在Python中，如果你使用浅拷贝将可变对象 a 复制给变量 b，并且 a 和 b 都指向同一个可变对象，那么对 a 所指向的对象的修改将会反映在 b 中。
浅拷贝创建了一个新的对象 b，该对象与 a 共享相同的内容（指向相同的内存地址）。这意味着对于可变对象来说，如果你修改了 a 指向的对象，这些修改也会反映在 b 中，因为它们实际上指向同一个对象。
import copy
a = [1, 2, 3]
b = copy.copy(a) # 使用浅拷贝将 a 复制给 b
print(a) # 输出: [1, 2, 3]
print(b) # 输出: [1, 2, 3]
a.append(4) # 修改 a 所指向的可变对象
print(a) # 输出: [1, 2, 3, 4]
print(b) # 输出: [1, 2, 3, 4]，b 也被修改了
可以看到，尽管我们只对 a 进行了修改，但是 b 也随之改变了。这是因为 a 和 b 都指向同一个可变对象。
需要注意的是，如果修改的是不可变对象（如元组），那么即使进行了浅拷贝，b 也不会受到影响，因为不可变对象无法被修改。
题目就是第二种情况 指向的1是整型 是不可变对象 所以被浅拷贝的对象不会被影响
发表于 2023-07-07 17:17:27
回复(0)
错因：对深拷贝和浅拷贝的特性不熟悉。
深拷贝完全复制出一个全新的对象，包括原有对象的父对象和子对象，因此原有对象的父对象和子**的改变均不会影响到深拷贝后的对象
浅拷贝则是仅复制原对象的父对象而不复制其子对象，即复制后二者关于子对象的指针指向的是同一个对象，因此原对象父对象改变不影响拷贝后的，但子对象改变却影响
发表于 2022-02-15 21:40:57
回复(0)
问题信息
-
扫描二维码，关注牛客网
- 意见反馈
-
下载牛客APP，随时随地刷题
扫一扫，把题目装进口袋
- 求职之前，先上牛客
-
扫描二维码，进入QQ群
扫描二维码，关注牛客公众号
- 公司地址：北京市朝阳区北苑路北美国际商务中心K2座一层-北京牛客科技有限公司
- 联系方式：010-60728802 投诉举报电话：010-57596212（朝阳人力社保局）
- 牛客科技© All rights reserved admin@nowcoder.com
- 京ICP备14055008号-4 增值电信业务经营许可证 营业执照 人力资源服务许可证
-
京公网安备
11010502036488号
