Python中浅拷贝的四种实现方法小结

目录
  • 方式一:使用切片 [:]
  • 方式二:使用工厂函数
  • 方式三:使用数据类型自带的 copy 方法
  • 方式四:使用 copy 模块的 copy 方法

方式一:使用切片 [:]

列表

# 浅拷贝 [:]
old_list = [1, 2, [3, 4]]
new_list = old_list[:]

old_list.append(5)
old_list[2][0] += 97

print("Old list:", old_list, "old list id:", id(old_list), " old list[0] id:", id(old_list[2]))
print("new list:", new_list, "new list id:", id(new_list), " new list[0] id:", id(new_list[2]))

# 输出结果
Old list: [1, 2, [100, 4], 5] old list id: 4537660608  old list[0] id: 4537659840
new list: [1, 2, [100, 4]] new list id: 4537711424  new list[0] id: 4537659840

方式二:使用工厂函数

工厂函数简介

  • 工厂函数看上去像函数,但实际是一个类
  • 调用时,生成该数据类型类型的一个实例

可变对象的工厂函数

  • list()
  • set()
  • dict()

列表

old_list = [1, 2, [3, 4]]
new_list = list(old_list)

old_list.append(5)
old_list[2][0] += 97

print("Old list:", old_list, "old list id:", id(old_list), " old list[0] id:", id(old_list[2]))
print("new list:", new_list, "new list id:", id(new_list), " new list[0] id:", id(new_list[2]))

集合

old_set = {1, 2, 3}
new_set = set(old_set)

old_set.add(4)

print("Old set:", old_set, "old set id:", id(old_set))
print("new set:", new_set, "new set id:", id(new_set))

# 输出结果
Old set: {1, 2, 3, 4} old set id: 4484723648
new set: {1, 2, 3} new set id: 4484723872

字典

old_dict = {"name": "小明"}
new_dict = dict(old_dict)

old_dict["second"] = "Python"

print("Old dict:", old_dict, "old dict id:", id(old_dict))
print("new dict:", new_dict, "new dict id:", id(new_dict))

# 输出结果
Old dict: {'name': '小明', 'second': 'Python'} old dict id: 4514161536
new dict: {'name': '小明'} new dict id: 4515690304

方式三:使用数据类型自带的 copy 方法

列表

old_list = [1, 2, [3, 4]]
new_list = old_list.copy()

old_list.append(5)
old_list[2][0] += 97

print("Old list:", old_list, "old list id:", id(old_list), " old list[0] id:", id(old_list[2]))
print("new list:", new_list, "new list id:", id(new_list), " new list[0] id:", id(new_list[2]))

# 输出结果
Old list: [1, 2, [100, 4], 5] old list id: 4309832000  old list[0] id: 4310372992
new list: [1, 2, [100, 4]] new list id: 4309735296  new list[0] id: 4310372992

集合

old_set = {1, 2, 3}
new_set = old_set.copy()

old_set.add(4)

print("Old set:", old_set, "old set id:", id(old_set))
print("new set:", new_set, "new set id:", id(new_set))

# 输出结果
Old set: {1, 2, 3, 4} old set id: 4309931392
new set: {1, 2, 3} new set id: 4309930944

字典

old_dict = {"name": "小明"}
new_dict = old_dict.copy()

old_dict["second"] = "Python"

print("Old dict:", old_dict, "old dict id:", id(old_dict))
print("new dict:", new_dict, "new dict id:", id(new_dict))

# 输出结果
Old dict: {'name': '小明', 'second': 'Python'} old dict id: 4308452288
new dict: {'name': '小明'} new dict id: 4308452224

源码

    def copy(self, *args, **kwargs): # real signature unknown
        """ Return a shallow copy of the list. """
        pass

已经写的很清楚,这是浅拷贝

方式四:使用 copy 模块的 copy 方法

列表

from copy import copy

old_list = [1, 2, [3, 4]]
new_list = copy(old_list)

old_list.append(5)
old_list[2][0] += 97

print("Old list:", old_list, "old list id:", id(old_list), " old list[0] id:", id(old_list[2]))
print("new list:", new_list, "new list id:", id(new_list), " new list[0] id:", id(new_list[2]))

# 输出结果
Old list: [1, 2, [100, 4], 5] old list id: 4381013184  old list[0] id: 4381159936
new list: [1, 2, [100, 4]] new list id: 4381012800  new list[0] id: 4381159936

集合

from copy import copy

old_set = {1, 2, 3}
new_set = copy(old_set)

old_set.add(4)

print("Old set:", old_set, "old set id:", id(old_set))
print("new set:", new_set, "new set id:", id(new_set))

# 输出结果
Old set: {1, 2, 3, 4} old set id: 4381115552
new set: {1, 2, 3} new set id: 4381115776

字典

from copy import copy

old_dict = {"name": "小明"}
new_dict = copy(old_dict)

old_dict["second"] = "Python"

print("Old dict:", old_dict, "old dict id:", id(old_dict))
print("new dict:", new_dict, "new dict id:", id(new_dict))

# 输出结果
Old dict: {'name': '小明', 'second': 'Python'} old dict id: 4381159680
new dict: {'name': '小明'} new dict id: 4379632576

到此这篇关于Python中浅拷贝的四种实现方法小结的文章就介绍到这了,更多相关Python 浅拷贝内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 详解Python直接赋值,深拷贝和浅拷贝

    直接赋值: 对象的引用,也就是给对象起别名 浅拷贝: 拷贝父对象,但是不会拷贝对象的内部的子对象. 深拷贝: 拷贝父对象. 以及其内部的子对象 在之前的文章中,提到可变对象和不可变对象,接下来也是以这两者的区别进行展开 直接赋值 对于可变对象和不可变对象,将一个变量直接赋值给另外一个变量,两者 id 值一致,其实本质上是将变量量绑定到对象的过程. >>> a=1 >>> b=a >>> id(a) == id(b) True >>>

  • 浅述python中深浅拷贝原理

    前言 在c++中参数传递有两种形式:值传递和引用传递.这两种方式的区别我不在此说,自行补上,如果你不知道的话.我先上python代码,看完我们总结一下,代码如下: # copy module import import copy # number and string a = 12 a1 = a a2 = copy.copy(a) a3 = copy.deepcopy(a) # look addr print("==========number=======") print(id(a)

  • 对于Python深浅拷贝的理解

    1,浅拷贝是什么? 浅拷贝是对于一个对象的顶层拷贝,通俗的理解是:拷贝了引用,并没有拷贝内容 通过a=b这种方式赋值只是赋值的引用(内存地址),a和b都指向了同一个内存空间,所以他们的id(地址相同),这种就是浅拷贝 2,深拷贝是什么? 通过调用copy包里的deepcopy方法来深拷贝,其实就是在内存区在分配保存了和a相同的数据,用c来指向它,和a的内存地址不同.怎么验证就是我说的这种情况的呢?用下图来说明吧: 可以看出向a 添加一个元素,通过浅拷贝的b也随着改了,但是通过深拷贝的c没改,可以

  • Python的赋值、深拷贝与浅拷贝的区别详解

    在python中,给一个对象赋值,实际上就是对象对内存空间存储的值的引用.当我们把对象赋值给另一个变量的时候,这个变量并没有拷贝这个对象,而只是拷贝了这个对象的引用而已. 一般情况下我们会通过三种方法来实现拷贝对象的引用. Python直接赋值 直接赋值,默认浅拷贝传递对象的引用而已,原始列表改变,被赋值的变量也会做相同的改变.其实就是对'对象'的引用 示例: >>> list_demo = [2, 4, 6] >>> a = list_demo >>>

  • Python直接赋值及深浅拷贝原理详解

    定义 直接赋值:就是对象的引用(别名) 浅拷贝(copy):拷贝父对象,不拷贝对象内部的子对象 深拷贝(deepcopy):copy模块的deepcopy方法,完全拷贝父对象及其子对象 解释 b = a: 赋值引用,a和b都指向同一个对象 b = a.copy(): 浅拷贝,a和b都是一个独立的对象,但它们的子对象是指向统一对象(是引用) b = copy.deepcopy(a): 深拷贝,a和b完全拷贝了父对象及其子对象,两者是完全独立的 示例 以下是直接赋值.浅拷贝和深拷贝之对比 impor

  • Python中浅拷贝copy与深拷贝deepcopy的简单理解

    以下是个人对Python深浅拷贝的通俗解释,易于绕开复杂的Python数据结构存储来进行理解! 高级语言中变量是对内存及其地址的抽象,Python的一切变量都是对象. 变量的存储采用了引用语义的方式,存储的只是一个变量的值所对应的地址信息. 变量的每一次初始化(赋值),即将新的内容的地址赋给变量. 复杂数据结构存储的是各个元素的值得存储位置. 进行增删改等操作时不改变数据本身的id,改变的各个元素的地址引用. 改变任何一个拥有相同id的变量时,其他相同id的变量也会相应改变. copy.copy

  • 详解python深浅拷贝区别

    在Python中对象的赋值其实就是对象的引用.当创建一个对象,把它赋值给另一个变量的时候,python并没有拷贝这个对象,只是拷贝了这个对象的引用而已. 浅拷贝:拷贝了最外围的对象本身,内部的元素都只是拷贝了一个引用而已.也就是,把对象复制一遍,但是该对象中引用的其他对象我不复制 深拷贝:外围和内部元素都进行了拷贝对象本身,而不是引用.也就是,把对象复制一遍,并且该对象中引用的其他对象我也复制. 深浅拷贝的作用 1,减少内存的使用 2,以后在做数据的清洗.修改或者入库的时候,对原数据进行复制一份

  • Python深拷贝与浅拷贝用法实例分析

    本文实例讲述了Python深拷贝与浅拷贝用法.分享给大家供大家参考,具体如下: 1.对象的赋值 对象的赋值实际上是对象之间的引用:当创建一个对象,然后将这个对象赋值给另外一个变量的时候,python并没有拷贝这个对象,而只是拷贝了这个对象的引用. 当对对象做赋值或者是参数传递或者作为返回值的时候,总是传递原始对象的引用,而不是一个副本.如下所示: 在python中将一个变量赋值给另一个变量,传递的是引用.无论是a的内层变化还是外层变化,b都会发生同样的变化.因为b和a指向了同一个引用.类似于c语

  • Python基础之赋值,浅拷贝,深拷贝的区别

    一.赋值 不会开辟新的内存空间,只是复制了新对象的引用.所以当一个数据发生变化时,另外一个数据也会随之改变. 二. 浅拷贝 创建新对象,其内容是对原对象的引用.浅拷贝之所以称为浅拷贝,是因为它仅仅只拷贝了第一层,即只拷贝了最外层的对象本身,内部的元素都只是拷贝了一个引用而已,即内部元素如果被修改,则另外一个数据也会发生变化. 浅拷贝的三种形式: A = [1, 2, 3, 4] 切片操作 # 第1种 B = A[:] # 第2种 B = [a for a in A] 工厂函数 B = list(

  • Python字典深浅拷贝与循环方式方法详解

    本节内容 深浅拷贝 循环方式 字典常用方法总结 一.深浅拷贝 列表.元组.字典(以及其他) 对于列表.元组和字典而言,进行赋值(=).浅拷贝(copy).深拷贝(deepcopy)而言,其内存地址是变化不通的. 赋值(=) 赋值只是创建一个变量,该变量指向原来的内存地址 >>> name1 = ['a','b',['m','n'],'c'] >>> name2 = name1 #输出结果,两个内存地址是一样的 >>> print(id(name1),'

随机推荐