首页 > 试题广场 >

在python3中，对程序结果说明正确的是： dicts =

[单选题]

在python3中，对程序结果说明正确的是：

dicts = {'one': 1, 'two': 2, 'three': 3}
tmp = dicts.copy()
tmp['one'] = 'abc'
print(dicts)
print(tmp)

['one': 1, 'two': 2, 'three': 3]，['one': 'abc', 'two': 2, 'three': 3]

{'one': 1, 'two': 2, 'three': 3}，{'one': 'abc', 'two': 2, 'three': 3}

{'one': 'abc', 'two': 2, 'three': 3}，{'one': 'abc', 'two': 2, 'three': 3}

{'one': 1, 'two': 2, 'three': 3}，{'one': 1, 'two': 2, 'three': 3}

查看答案及解析

化生优质考生

注意：字典数据类型的copy函数，当简单的值替换的时候，原始字典和复制过来的字典之间互不影响，但是当添加，删除等修改操作的时候，两者之间会相互影响。

所以新字典的值的替换对原字典没有影响

发表于 2021-12-13 08:35:14 回复(10)

盟军敢死队

1. dict.copy() 是对字典的浅复制，复制以后，两个dict的内存地址不同，但dict内部各个key的内存地址相同。所以题目中的

id(dicts) != id(tmp)
id(dicts['one']) == id(tmp['one'])
id(dicts['two']) == id(tmp['two'])
id(dicts['three']) == id(tmp['three'])

2. 对于不可变变量（如数字，字符串，元组）的重新赋值，会改变变量对应的内存地址。所以题目中对于tmp['one']重新赋值以后，此时的tmp['one']内存地址改变了，不等于原来的tmp['one']的内存地址，所以tmp['one']的值也改变了。但是dicts['one']的内存地址没有改变，还是原来的内存地址，所以dicts['one']的值没改变。所以你会发现答案里，tmp['one']的值改变了，而dicts['one']的值没有改变。即答案为

dicts = {'one': 1, 'two': 2, 'three': 3}
tmp = {'one': 'abc', 'two': 2,  'three': 3}

3. 对于可变变量，添加和修改数据，不会改变变量对应的内存地址。所以如果题目中tmp['one']的值改为列表等可变变量时，再去修改tmp['one']中元素的值，你会发现tmp和dicts中的值都会改变，因为它们引用的是同一个内存地址的数据。即为

dicts = {'one': [7, 8], 'two': 2, 'three': 3}
tmp = dicts.copy()
tmp['one'][0] = 10
# 修改以后的结果
dicts = {'one': [10, 8], 'two': 2, 'three': 3}
tmp = {'one': [10, 8], 'two': 2, three: 3}

4. 对于可变变量，如果是重新赋值，而非添加和修改数据，也会改变变量对应的内存地址。所以如果题目中tmp['one']的值改为列表等可变变量时，再对tmp['one']重新赋值（而不是像第三点一样修改tmp['one']中元素的值时），你会发现tmp['one']和dicts['one']的值又不同了，因为重新赋值以后，此时tmp['one']的内存地址改变了，和原来的tmp['one']内存地址不同，而dicts['one']的内存地址还和原来一样。即为

dicts = {'one': [7, 8], 'two': 2, 'three': 3}
tmp = dicts.copy()
tmp['one'] = [9, 10]
# 答案为
dicts = {'one': [7, 8], 'two': 2, 'three': 3}
tmp = {'one': [9, 10], 'two': 2, 'three': 3}

发表于 2022-09-16 21:31:02 回复(3)

麟🔥

浅拷贝跟深拷贝的区别吧对于字典、列表、集合来说，浅拷贝只拷贝对应的内存地址，而深拷贝会完全复制拷贝一份新的而对于字符串、数字这些，浅拷贝跟深拷贝都是一样拷贝一份新的。 old_dicts = {'name': tom, 'age': 18, 'like': [1,2,3]} 浅拷贝 new_dicts = old_dicts. copy() 修改name 或者 age 时，不会相互影响，而修改like时，会互相影响。深拷贝 new_deep_dicts = old_dicts. deepcopy() 就是完完全全复制了一份新的，从头复制到尾，是相互独立的两个字典了，不管怎么修改都不会影响到对方

编辑于 2022-02-22 21:55:38 回复(7)

ml_YSY

dicts = {'one': 1, 'two': 2, 'three': 3}    # 创建字典dicts，并将'one': 1, 'two': 2, 'three': 3赋值给字典dicts
tmp = dicts.copy()                          # 创建变量tmp，复制字典dicts，将其赋值给变量tmp
tmp['one'] = 'abc'                          # 将tmp变量中key值为one的value值替换成字符串abc
print(dicts)                                # 输出字典dicts的值
print(tmp)                                  # 输出变量tmp的值

copy方法，将当前的列表复制一份相同的列表，新列表与旧列表内容相同，但内存空间不同

记住这一句就行了，记住它的核心，比什么都强，什么题就记什么知识点

发表于 2022-05-06 17:28:12 回复(1)

牛客183037318号

眼神不好，应该是字典

发表于 2022-03-27 20:06:31 回复(3)

复唧唧

其实本质原理非常的简单：就是拷贝了新的一份字典对象，但是不完全拷，字典里面的元素地址还是原来的地址。简单在于：你要忘记这些规则，你始终记住，列表可以修改的，地址永远只有一份，无论你在哪个字典对象修改字典，大家都会改变，字符串，数字，元组是不可修该的，所以其中一份字典对象替换数字，字符串的值，其实是创建新的一个数字，字符串对象了。

发表于 2022-10-28 10:38:52 回复(0)

拒绝了校花

涉及到深拷贝浅拷贝问题，当数据类型是数字和字符串时候，深拷贝浅拷贝都是复制一份独立新的栈空间存储，如果是列表字典集合时，浅拷贝是地址拷贝，公用一个对象，会相互影响，深拷贝则不会

发表于 2022-05-29 10:32:03 回复(0)

jia2023

dict1= {'name':'小小','age':[1,2,3]}
dict2 = dict1 #浅拷贝：引用对象，内存地址相同，随原对象改变而改变
dict3 = dict1.copy() #一级目录深拷贝，独立内存空间；子对象（二级目录）浅拷贝
dict3['name'] = 'small'
dict1['age'].remove(1)
print(dict1) #{'name': '小小', 'age': [2, 3]}
print(dict2) #{'name': '小小', 'age': [2, 3]}
print(dict3) #{'name': 'small', 'age': [2, 3]} 父对象独立内存地址，原数据不变，复制对象变；子对象内存地址相同随原数据而变

编辑于 2022-03-01 20:10:00 回复(3)

完美的无尾熊等oc

A选项和B选项一样？

发表于 2022-02-09 10:45:32 回复(4)

想牛的白

我觉得这题是在考对顶层对象的理解。对于本题个字典对象，它的顶层对象就是字典本身。如果字典中的值是列表或其他字典，那么这些嵌套的对象不属于顶层对象。直接包含在字典中的键和值是顶层对象。本题目就是直接包含在字典中的键值对。

发表于 2023-09-19 16:59:28 回复(1)

西鱼202306021037160

.copy对字典进行了一个浅拷贝，浅拷贝的意思是创建了一个新的字典与原来的字典无关，也可以理解为值传递。当只使用＝传递时，两个字典同时改变，共用一个地址。

发表于 2023-07-13 12:38:41 回复(0)

牛客290659675号

浅复制只能保证浅数列的独立，深度数列仍是复制地址，产生的变更会影响两个数列

dicts = {'one': [2,4,6], 'two': 2, 'three': 3}
tmp = dicts.copy()
tmp['one'][0] = 'abc'
tmp['three']=8
print(dicts)
print(tmp)

{'one': ['abc', 4, 6], 'two': 2, 'three': 3}
{'one': ['abc', 4, 6], 'two': 2, 'three': 8}

发表于 2023-07-07 22:30:54 回复(0)

牛客278888939号

A和B答案一样不应该都对么

发表于 2022-09-16 10:24:19 回复(0)

牛客718724413号

眼神不好，居然选了A

发表于 2022-06-30 12:01:45 回复(0)

为祖国建设，艰苦奋斗五十年～

浅拷贝与深拷贝: 对于不可变对象来说，两种拷贝都是拷贝一份新的。对于可变对象来说，浅拷贝拷贝对应内存地址，深拷贝拷贝成一份新的。浅拷贝中对象的子元素如果为可变对象，则会相互影响；为不可变对象时，则不会相互影响。

编辑于 2024-03-25 12:33:16 回复(0)

万能的翔王大人

dicts = {'one': [1], 'two': 2, 'three': 3}
tmp = dicts.copy() # 浅拷贝dicts
tmp['one'].append(2) 
tmp['one'].append(3)
tmp['two'] = 3
print(dicts)
print(tmp)

在 Python 中，浅拷贝（Shallow Copy）是创建一个新的对象，然后将原对象中的元素的引用复制到新对象中。这意味着新对象和原对象中的元素实际上是同一个对象。因此，如果你修改了新对象中的一个元素，那么原对象中的对应元素也会被修改，反之亦然。

编辑于 2024-01-16 10:21:11 回复(0)