python中for循环和列表_python集合for循环列表删除问题

1. for循环的问题.

2. str操作

join() 把列表变成字符串

split() 把字符串转换成列表

3. list的删除问题(绕)

列表在循环的时候如果执行了删除操作. 索引和长度会有变化. 这种删除是不安全.

先把要删除的内容放在一个新列表中. 然后循环这个新列表. 删除老列表.

dict在循环过程中是不允许删除的.

把要删除的键放在列表中. 循环列表删除字典

4. set集合

无序的. 不重复的. 内容必须是可哈希的数据类型.

本身是不可哈希

添加:add(),update(),

删除:pop()

查询:可迭代对象

需要可哈希的时候用frozenset()

5. 深浅拷贝

拷贝是复制一份

浅拷贝: 只会拷贝第一层内容. 第二层的内容不会拷贝

1. copy() 2.[:]

深拷贝: 拷贝所有内容. 包括里层的所有内容

下面是详细内容

for 循环增加了解

for 循环架构

for .....

else:

代码块

这里和while是一样的,如果循环正常结束的话,那么执行else的代码,如果是通过break跳出的话,不执行else的.

示例如下:

s = "abcdefg"

for w ins:print(w)if w == "f":break

else:print("哈哈")"""执行结果如下:

a

b

c

d

e

f"""

str 操作 (join方法)

join方法主要是列表生成字符串的操作,把列表所有内容迭代用左边的字符连起来.

具体方法是"边接字符".join(迭代对像)

这里要注意只有是字符连接,不能是整数.处理的值是迭代对像都可以.

示例如下:

s = ["1","2","3","4","5"]

s2= "_".join(s)print(s2)"""执行结果如下:

1_2_3_4_5"""

列表转成字符串,可以通过下面来转

lst = ["a","b","c"]

s = "".join(lst)

list的删除问题

介绍:列表如下删除有两个错误,是因为列表在删除的过程中列表的索引和长度发生了变化,所以产生的结果也不同

示例:

lst = ["水浒","红楼","西游","三国"]for w inlst:

lst.remove(w)print(lst)"""生成的结果却并不是空的,而是下面这个值

['红楼', '三国']"""

这个的原因是w在for里面每次是增加的,通过增加后找相应索引位置的值.

当我们删除第1个索引的值后,列表发生变化,向左移动一下.原来第二位置的值变成了第一个索引.所以删除会隔着删除.索引是不断增加的,增加后在变化后的列表中找到对应的值,找不到就退出

同时的这样的示例也会出错

lst = ["水浒","红楼","西游","三国","孙悟空","孙行者","lkjjlj","kjlkjljlkj"]#for w in lst:#lst.remove(w)#print(lst)

for w inrange(0,len(lst)):dellst[w]print(lst)"""这样写的话,会报下面的错误:

Traceback (most recent call last):

File "D:/python/测试.py", line 32, in

del lst[w]

IndexError: list assignment index out of range"""

原理大致也是因为按索引删除后,后面的列表没有这个索引了,会报错的.

正确的写法如下:

lst = ["水浒","红楼","西游","三国","孙悟空","孙行者","lkjjlj","kjlkjljlkj"]#for w in lst:#lst.remove(w)#print(lst)#for w in range(0,len(lst)):#del lst[w]#print(lst)

lst2 =lst.copy()for w inlst2:

lst.remove(w)print(lst)"""结果是正确的空列表"""

另外一个重要的知识点是字典在循环的过程中是不能删除的.如下示例

dic = {"a":"好人","b":"坏人"}for w indic:

dic.pop(w)print(dic)"""会报以下错误

Traceback (most recent call last):

File "D:/python/测试.py", line 39, in

for w in dic:

RuntimeError: dictionary changed size during iteration"""

如果想删除只能和列表一样,单独存一个列表,循环这个列表删除,参考示例如下:

dic = {"a":"好人","b":"坏人"}#for w in dic:#dic.pop(w)#print(dic)

lst=[]for w indic.keys():

lst.append(w)for w inlst:

dic.pop(w)print(dic)

dict中的fromkey(),可以帮我们通过list来创建⼀一个dict

示例:

dic = dict.fromkeys(["a","b","c"],["d","e"])print(dic)

"""

输出结果是

{'a': ['d', 'e'], 'b': ['d', 'e'], 'c': ['d', 'e']}

"""

这个dist.fromkey主要是把第一个值迭代当成key,第二个值当作value传给字典.

这里有一个坑 ,这个value传给key时,传的是同一个内存地址,如果发生变化,值都会变.如下示例:

dic = dict.fromkeys(["a","b","c"],["d","e"])

dic["a"].append("哈哈")print(dic)"""{'a': ['d', 'e', '哈哈'], 'b': ['d', 'e', '哈哈'], 'c': ['d', 'e', '哈哈']}"""

可以看到上面结果都有"哈哈"可实际上我只修改了第一个key的值.

同时也要注意,dict.fromkey并不是在原字典上作修改,而是生成字典,

示例如下:

dic ={}

dic2= dic.fromkeys("ab","cd")print(dic)print(dic2)"""{}

{'a': 'cd', 'b': 'cd'}"""

类型转换:

列表转元组   list ----> tuple(lst)

元组转list     tu ----> list(tu)

示例:

lis = ["1","2","3"]

tu=tuple(lis)print(lis)print(tu)

列表转成str 是通过join(列表)

str转成列表可以通过split和extend

集合

集合有三个方面,一个是无序的,一个是去重的,一个是元素是可hash的(也就是不可变的),但是集合本身是不可hash的,也就是可变的.集合可以理解成字典的key的组合.

set也用{}表示.

根据如上特性,可以做如下测试:

set1 = {1,2,3,[]}print(set1)"""运行后会报如下错误

set1 = {1,2,3,[]}

TypeError: unhashable type: 'list'"""

也可以做去重测试.

set1 = {1,2,3,1}print(set1)"""运行以后报如下错误

{1, 2, 3}"""

这里有一个重要应用,列表去重.如下:

lst = [1,4,3,8,0,3,2,5,1]

set1=set(lst)print(set1)

lst=list(set1)print(lst)

set集合增删改查

增

增是通过add和update来增加的.(update是迭代更新的)

s.add("增加的值")###重复的内容不不会被添加到set集合中

集合的初始化可以通过这个来初始化

s =set()

s.add("我的值")print(s)

s.update()迭代update里面的内容传和集合当中

示例如下:

s =set()

s.update("abc")print(s)

s.update(["我","你","他"])print(s)

删除

删除有三个操作s.pop()随机删除.s.clear()清空集合.s.remove()删除某个具体的元素.

示例如下:

s =set()

s.update("abcdef")

item=s.pop()print(s)print(item)

s.remove("b")print(s)

s.clear()print(s)

这里注意两点,如果remove删除的元素不存在的话,会报错的.另外一个空集合并不是{}而是set()

改

集合的改就是先删除,后添加

查

for循环来查,示例如下:

s =set()

s.update("abcdef")for w ins:print(w)

集合的常⽤操作

集合的操作有交集和并集,以及差集,其他暂时 不做了解.

示例如下:

s =set()

s.update("abcdef")

s2=set()

s2.update("bdljlj")print(s2)print(s)print(s-s2) #差集

print(s & s2) #交集

print(s | s2) #并集

深浅copy

如果是赋值的话,两个变量用的是一个内存地址.如果你想用两个内存地址的话,需要用到copy这个东西,示例如下:

lst =[]

lst.extend("abcdefg")print(lst)

lst1=lstprint(id(lst),id(lst1)) #两个内存地址是一样的.

lst1 = lst.copy() #如果想获取两个不同的内存地址的话,可以用浅copy.

print(id(lst),id(lst1))

这个copy使用是使用.lst.copy()方法来实现的.但是这个会有个问题.比如如下:

lst =[]

lst.extend("abcdefg")

lst.append(["中文","英文"])

lst1= lst.copy() #如果想获取两个不同的内存地址的话,可以用浅copy.

print(lst)print(lst1)

lst1[-1].append("外文")print(lst) #浅copy的问题是对于列表中的列表再修改的话,是会有问题的.因为浅copy只是copy了列表的内存地址

print(lst1)

原因就是浅copy只是copy的列表等可变元素的内存地址.解决办法就是用深copy

深copy的使用方法是

import copy

lst1 = copy.deepcopy(lst)

示例:

importcopy

lst=[]

lst.extend("abcdefg")

lst.append(["中文","英文"])

lst1=copy.deepcopy(lst)print(lst)print(lst1)

lst1[-1].append("外文")print(lst) #深copy无论里面,无论几层,都会重新copy的.当然会浪费一点内存

print(lst1)