python(6)——循环删除list、深拷贝和浅拷贝

 列表的内存自动管理功能,在删除列表中的元素时,python会自动对列表内存进行收缩,并移动列表中的元素以保证元素之间没有间隙,所以使用

      “循环+remove()方法”来删除列表中元素时会出现元素错位

#删除list1中的奇数
ist1=[1,1,1,2,3,4,5]

for i in list1:
    if i%2!=0:
        list1.remove(i)
print(list1)    #[1,2,4]
若要正确循环删list中的元素,定义两个相同的list。一个list用于循环,从另一个list中删除
import  copy
list1=[1,1,1,2,3,4,5]
list2=[1,1,1,2,3,4,5]

for i in list2:
    if i%2!=0:
        list1.remove(i)

print(list1)   #[2,4]

浅拷贝

#list2=list1 相当于 list2=list1.copy(),都是浅拷贝
#list2和list1指向同一个内存地址,所以list1变了,list2也会变 ;同样不能达到正确删除list1中奇数的目的

list1=[1,1,1,2,3,4,5]
list2=list1             #浅拷贝   相当于 list1.copy()
print(id(list1))     # 2270067237960   id()取内存地址
print(id(list2))     # 2270067237960

for i in list2:
    if i%2!=0:
        list1.remove(i)
print(list1)        #[1,2,4]

深拷贝

# list2=copy.deepcopy(list1)   深拷贝,list1和list2指向不同的内存地址

import  copy   #导入copy模块
list1=[1,1,1,2,3,4,5]
list2=copy.deepcopy(list1)  #深拷贝
print(id(list1))     #2085723515720  id()取内存地址
print(id(list2))     #2085723513928
for i in list2:
    if i%2!=0:
        list1.remove(i)
print(list1)      #[2,4]

字符串的值是不能改变的,所以字符串和list情况不同

1 a=‘cat‘     #a中保存的是cat的内存地址
2 b = a       #将a中保存的内存地址赋给b,a和b指向同一块内存地址
3 a=‘dog‘    #字符串的值是不能改变的,所以重新对a赋值会在分配一块内存给dog,a指向dog的内存地址
4 print(a)    #dog
5 print(b)    #ca

原文地址:https://www.cnblogs.com/HathawayLee/p/9622526.html

时间: 2024-10-12 20:11:33

python(6)——循环删除list、深拷贝和浅拷贝的相关文章

python之copy模块与深拷贝、浅拷贝

copy模块 使用copy模块来实现复制功能. 复制方法分为浅拷贝与深拷贝: 浅拷贝, copy.copy(object) 对内存地址进行复制,目标对象和源对象指向同一内存片内存空间. 深拷贝, copy.deepcopy(object) 为复制生成的对象也申请一个单独的内存空间,内存地址是自主分配的. 完成复制后,目标对象和源对象虽然存储数据是一样的,但是内存地址不同. 两个对象互不干涉. 例: >>> jack = ['jack', ['age', '20']]>>>

python中循环删除列表中元素时的坑![转]

原博文链接:https://www.cnblogs.com/baihualin/p/10698651.html 循环删除列表中元素时千万别用正序遍历,一定要用反序遍历! 废话不多说,先上案例代码: def test(data): for i in data: data.remove(i) return data data = [1, 2, 3] print(test(data)) 面对以上代码,乍一看以为会打印出空列表,因为test函数内通过for的方法将data中的元素都删除了,其实不然,实际

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 深拷贝与浅拷贝

浅拷贝的方式有: lst=[1,2,3] (1)直接赋值: lst_cp = lst (2)for循环遍历生成:lst_cp= [i for i in lst] (3)copy模块下,copy.copy仍为浅拷贝 深拷贝的方式 (1)借助copy模块 >>> import copy >>> lst_cp = copy.deepcopy(lst) 以上方法的测试: 注意:因为string类型是不可变类型,所以修改string元素时会新创建一个地址空间放置数据 (1)直接赋

Python之美[从菜鸟到高手]--浅拷贝、深拷贝完全解读(copy源码分析)

可悲的我一直以为copy模块是用C写的,有时候需要深入了解deepcopy,文档描述的实在太简单,还是不知所云. 比如说最近看sqlmap源码中AttribDict的_deepcopy__有些疑惑, def __deepcopy__(self, memo): retVal = self.__class__() memo[id(self)] = retVal for attr in dir(self): if not attr.startswith('_'): value = getattr(se

Python中list的复制及深拷贝与浅拷贝探究

在Python中,经常要对一个list进行复制.对于复制,自然的就有深拷贝与浅拷贝问题.深拷贝与浅拷贝的区别在于,当从原本的list复制出新的list之后,修改其中的任意一个是否会对另一个造成影响,即这两个list在内存中是否储存在同一个区域,这也是区分深拷贝与浅拷贝的重要依据.接下来我们就针对Python中list复制的几种方法,来探究一下其是属于深拷贝还是浅拷贝.弄清楚这个问题,有助于我们在编程中规避错误,减少不必要的调试时间. 一.非拷贝方法--直接赋值 如果用=直接赋值,是非拷贝方法.这

python:深拷贝,浅拷贝,内存管理

深拷贝和浅拷贝都是对象的拷贝,本质的区别是拷贝出来的对象的地址是否和原对象一样,也就是地址的复制还是值的复制的区别. 可变对象:直接在对象所指的地址上把值改了,这个对象依然指向这个地址. 不可变对象:一个对象所指向的地址上的值是不能修改的,如果修改了这个对象的值,它所指向的地址就改变了. 深拷贝就是完全跟以前就没有任何关系了,原来的对象怎么改都不会影响当前对象 浅拷贝,原对象的list元素改变的话会改变当前对象,如果当前对象中list元素改变了,也同样会影响原对象. 内存管理机制 python的

完全理解python深拷贝和浅拷贝

import copya = [1, 2, 3, 4, ['a', 'b']]  #原始对象b = a  #赋值,传对象的引用c = copy.copy(a)  #对象拷贝,浅拷贝d = copy.deepcopy(a)  #对象拷贝,深拷贝a.append(5)  #修改对象aa[4].append('c')  #修改对象a中的['a', 'b']数组对象print 'a = ', aprint 'b = ', bprint 'c = ', cprint 'd = ', d 输出结果:a = 

python 中 深拷贝和浅拷贝的理解

在总结 python 对象和引用的时候,想到其实 对于python的深拷贝和浅拷贝也可以很好对其的进行理解. 在python中,对象的赋值的其实就是对象的引用.也就是说,当创建一个对象,然后赋给另外一个变量之后,实际上只是拷贝了这个对象的引用. 我们先用  利用切片操作和工厂方法list方法 来阐述一下浅拷贝. 举个栗子: Tom = ['Tom', ['age', 10]] Jack = Tom[:] ……切片操作 June = list(Tom) 接下来查看一下 上述三个变量的引用: >>