列表相关函数,深浅拷贝,字典相关函数,集合相关操作及文件操作---day08
1.列表的相关函数
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 | append() 功能:向列表的末尾添加新的元素 格式:列表.append(值) 返回值: None 注意:新添加的值在列表的末尾,该函数直接操作原有列表 insert() 功能:在指定索引之前插入元素 格式:列表.insert(索引,值) 返回值: None 注意:直接改变原有列表 extend() 功能:迭代追加所有元素 格式:列表.extend(可迭代行数据) 返回值: None 注意:直接改变原有列表 pop() 功能:通过指定索引删除元素,若没有索引移除最后那个 格式:列表.pop(索引) 返回值:删除的元素 注意:没有指定索引,默认删除最以后一个元素 remove() 功能:通过给予的值来删除,如果多个相同元素,默认删除第一个 格式:列表.remove(值) 返回值:无 注意:如果有索引的情况推荐使用pop,效率高于remove clear() 功能:情况列表 格式:列表.clear() 返回值:空列表 index() 功能:获取某个值在列表中的索引 格式:列表.index(值[,start][,end]) #[]表达参数可选项 返回值:找到返回索引 (找不到报错) count() 功能:计算某个元素出现的次数 格式:列表.count(值) 返回值:次数 sort() 功能:列表排序(默认从小到大排序) 格式:列表.sort(reverse = False ) 返回值: None 注意:直接更改原列表 reverse() 功能:列表反转操作 格式:列表.reverse() 返回值: None 注意:直接更改原列表<br><br>注意:对字母进行排序字母排序依据ascii编码,字母是一位一位的进行比较,如果第一位相同再去比较第二位依次类推。<br>另外可以对中文进行排序,但是无规律可循 |
2.浅拷贝和深拷贝
1 2 3 4 5 6 | copy模块中有 浅拷贝 和 深拷贝两种方法 ( 1 )浅拷贝:浅拷贝只拷贝外层列表,内层列表跟随原列表进行改变 浅拷贝copy.copy(listvar)或listvar.copy() ( 2 )深拷贝:拷贝整个列表 内外列表都不跟随原列表进行改变 深拷贝copy.deepcopy(listvar) 注意:copy模块的copy方法和python内置的函数copy一样,都是浅拷贝 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | # ### 深拷贝 和 浅拷贝 ''' a = 19 b = a print(id(b),id(a)) #1433169504 1433169504 a = 20 print(b) #19 lst1 = [1,2,3] lst2 = lst1 lst1.append(4) print(lst2) #[1,2,3,4] ''' #(1) 浅拷贝(只拷贝一级所有的元素 其他层级延续以前的数据) #方法1 lst = [ 1 , 2 , 3 ] lst2 = lst.copy() lst.append( 5 ) print (lst) #[1,2,3,5] print (lst2) #[1,2,3] lst2[ 0 ] = 2 print ( id (lst[ 0 ]), id (lst2[ 0 ])) #1450011680 #1450011712 # 方法二(推荐) import copy lst = [ 1 , 2 , 3 ] '''copy.copy copy模块.copy函数()''' lst2 = copy.copy(lst) lst.append( 10 ) print (lst) #[1, 2, 3, 10] print (lst2) #[1, 2, 3] #存在二级容器(会沿用之前的数据 之前数据改变也会相应的改变) lst1 = [ 1 , 2 , 3 ,[ 4 , 5 , 6 ]] lst2 = copy.copy(lst1) lst1[ - 1 ].append( 10 ) print (lst1) #[1,2,3,[4,5,6.10]] print (lst2) #[1,2,3,[4,5,6.10]] #(2) 深拷贝(所有层级的元素都单独拷贝一份,形成独立的副本) ''' # 深拷贝语法copy.deepcopy()''' lst = [ 1 , 2 , 3 ,[ 4 , 5 , 6 ]] lst2 = copy.deepcopy(lst) lst[ - 1 ].append( 100 ) print (lst) #[1, 2, 3, [4, 5, 6, 100]] print (lst2) #[1, 2, 3, [4, 5, 6]] print ( id (lst[ - 1 ])) #32093456不一致 print ( id (lst[ - 1 ])) #45723467不一致 #深拷贝可以应用在字典当时 dic = { 'a' : 1 , 'b' :[ 1 , 2 , 3 ]} dic2 = copy.deepcopy(dic) dic[ 'b' ].append( 4 ) print (dic) #{'a':1,'b':[1,2,3.4]} print (dic2) #{'a':1,'b':[1,2,3]} #copy 和 deepcopy 谁更快 浅拷贝更快 # 浅拷贝:只拷贝第一层级所有的元素 copy.copy() 如存在第二层级 则沿用之前的数据 #深拷贝 :拷贝所有层级的元素 都单独开启新的空间 copy.deepcopy() #(地址:[不可变的数据类型]会暂时指向原数据 [可变的数据]会独立开辟空间) #可变数据:list set dict #不可变数据:int float bool complex str tuple lst1 = [ 1 , 2 , 3 ,[ 4 , 5 , 6 ]] lst2 = copy.copy(lst1) lst1[ 0 ] = 10 print (lst1) print (lst2) #[10, 2, 3, [4, 5, 6]] #[1, 2, 3, [4, 5, 6]] #浅拷贝 单独拷贝一级层级,lst1的一级层级改变,lst2的一级层级不变 #另外浅拷贝中当有二级层级时,沿用之前的二级层级,lst1的二级层级改变,lst2跟着改变 #深拷贝 全部单独拷贝一份 其中不可变的数据类型暂时指向原数据,节省内存 #可变的数据类型会单独开辟空间,lst1的二级层级改变,lst2的二级层级不改变 #因为都是单独独立的空间 |
3.字典的相关函数
1 2 3 4 5 6 7 8 9 10 11 12 | fromkeys() 使用一组键和默认值创建字典 st = [ 'a' , 'b' , 'c' ] dic = {}.fromkeys(lst, None ) print (dic) #{'a': None, 'b': None, 'c': None} #注意点 lst = [ 'a' , 'b' , 'c' ] dic2 = {}.fromkeys(lst,[ 1 , 2 ]) dic2[ 'a' ].append( 3 ) print (dic2) #{'a': [1, 2, 3], 'b': [1, 2, 3], 'c': [1, 2, 3]} #当用fromkeys创建键值对时,如值是可变的数据类型时, #在可变的列表中添加数据,对应的其他键值对的值也会同样添加相应的值 |
1 2 3 4 5 6 7 8 9 | pop() 通过键去删除键值对(若没有该键可设置默认值,预防报错) dic = { 'top' : 'the shy' , 'middle' : 'faker' , 'bottom' : '文森特' , 'jungle' : '鞋王' , 'support' : 'bao_blue' } #pop() 通过键去删除键值对(若没有该键可设置默认值,防止报错) res = dic.pop( 'bottom' ) print (res) #文森特 print (dic) #{'top': 'the shy', 'middle': 'faker', 'jungle': '鞋王', 'support': 'bao_blue'} #可在pop中第二个参数位置设置默认值,预防报错 res = dic.pop( 'bottom' , '没有' ) print (res) |
1 2 3 4 5 6 | popitem() 删除最后一个键值对 dic = { 'top' : 'the shy' , 'middle' : 'faker' , 'bottom' : '文森特' , 'jungle' : '鞋王' , 'support' : 'bao_blue' } res = dic.popitem() print (dic) #{'top': 'the shy', 'middle': 'faker', 'bottom': '文森特', 'jungle': '鞋王'} print (res) #('support', 'bao_blue') 删除的键值对以元组形式返回 |
1 2 3 4 | clear() 清空字典 dic.clear() print (dic) |
1 2 3 4 5 6 7 8 9 10 11 12 | update() 批量更新(有该键就更新,没有该键就添加) '''有该键就更新,没有该键就添加''' #方法一 推荐使用 dic = { "ww" : "大帅哥" , "spd" : "渣男" , "sql" : "负心男" } newdic = { "ww" : "美男子" , "wz" : "一表人才" , "yh" : "未来的土豪" } dic.update(newdic) print (dic) # {'ww': '美男子', 'spd': '渣男', 'sql': '负心男', 'wz': '一表人才', 'yh': '未来的土豪'} #方法二 dic.update(hj = '未来战士' ,wyq = '警察' ) print (dic) |
1 2 3 4 5 6 7 8 9 10 | get() 通过键获取值(若没有该键可设默认值,预防报错) dic = { "ww" : "大帅哥" , "spd" : "渣男" , "sql" : "负心男" } res = dic[ 'ww' ] print (res) # 大帅哥 #get方法可以预防报错 默认返回None res = dic.get( 'www' ) print (res) #None #get 方法可以设置默认值 res = dic.get( 'www' , '该键不存在' ) print (res) |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | keys() 将字典的键组成新的可迭代对象 values() 将字典的值组成新的可迭代对象 items() 将字典的键值对凑成一个个元组,组成新的可迭代对象 # keys() 将字典的键组成新的可迭代对象 dic = { "wy" : "智多星" , "lzs" : "花和尚" , "zs" : "浪里白条" } res = dic.keys() print (res) #dict_keys(['wy', 'lzs', 'zs']) 返回的是个可迭代对象,可以for循环取值 #values() 将字典中的值组成新的可迭代对象 dic = { "wy" : "智多星" , "lzs" : "花和尚" , "zs" : "浪里白条" } res = dic.values() print (res) ##dict_values(['智多星', '花和尚', '浪里白条'])返回的是个可迭代对象,可以for循环取值 #items() 将字典的键值对凑成一个个元组 组成新的可迭代对象 dic = { "wy" : "智多星" , "lzs" : "花和尚" , "zs" : "浪里白条" } res = dic.items() print (res) #dict_items([('wy', '智多星'), ('lzs', '花和尚'), ('zs', '浪里白条')]) #列表嵌套元组的形式存储 可通过for循环取值 |
1 2 3 4 5 6 7 8 9 10 11 12 | #变量的解包 dic = { "wy" : "智多星" , "lzs" : "花和尚" , "zs" : "浪里白条" } res = dic.items() print (res) #dict_items([('wy', '智多星'), ('lzs', '花和尚'), ('zs', '浪里白条')]) for k,v in res: print (k,v) ''' wy 智多星 lzs 花和尚 zs 浪里白条 ''' |
4.集合中的交差并补
1 2 3 4 5 6 7 8 9 | intersection() 交集 共有的 set1 = { "the shy" , "rookie" , "jacklove" , "神秘男孩" } set2 = { "蔡国庆" , "倪萍" , "赵忠祥" , "神秘男孩" } res = set1.intersection(set2) print (res) #{'神秘男孩'} #简写 & res = set1 & set2 print (res) #{'神秘男孩'} |
1 2 3 4 5 6 7 8 9 10 11 12 13 | difference() 差集 我有的你没有 set1 = { "the shy" , "rookie" , "jacklove" , "神秘男孩" } set2 = { "蔡国庆" , "倪萍" , "赵忠祥" , "神秘男孩" } res = set1.difference(set2) print (res) #{'jacklove', 'the shy', 'rookie'} res = set2.difference(set1) print (res) # {'蔡国庆', '倪萍', '赵忠祥'} #注意哪个集合在前 哪个集合在后 结果不一致 # 简写 res = set1 - set2 print (res) #{'jacklove', 'the shy', 'rookie'} |
1 2 3 4 5 6 7 8 9 | union() 并集,两个集合中所有元素包括共有的元素 集合自带去重 set1 = { "the shy" , "rookie" , "jacklove" , "神秘男孩" } set2 = { "蔡国庆" , "倪萍" , "赵忠祥" , "神秘男孩" } res = set1.union(set2) print (res) #{'the shy', '神秘男孩', '倪萍', '赵忠祥', 'rookie', 'jacklove', '蔡国庆'} #简写 | res = set1 | set2 print (res) |
1 2 3 4 5 6 7 8 9 10 | symmetric_difference() 对称差集(补集情况涵盖其中) #可以理解为除了交集以外的所有元素 set1 = { "the shy" , "rookie" , "jacklove" , "神秘男孩" } set2 = { "蔡国庆" , "倪萍" , "赵忠祥" , "神秘男孩" } res = set1.symmetric_difference(set2) print (res) #{'赵忠祥', '倪萍', 'rookie', '蔡国庆', 'the shy', 'jacklove'} #简写 ^ res = set1 ^ set2 print (res) |
1 2 3 4 5 6 7 8 9 10 11 12 13 | issubset() 判断是否是子集 set1 = { "张恒" , "杨浩" , "刘伟" } set2 = { "刘伟" } res = set1.issubset(set2) #set1是否是set2的子集 print (res) #False res = set2.issubset(set1) #set2是否是set1的子集 print (res) #True #简写 < set1 = { "张恒" , "杨浩" , "刘伟" } set2 = { "刘伟" } res = set1 < set2 print (res) #False |
1 2 3 4 5 6 7 8 9 | issuperset() 判断是否是父集 set1 = { "张恒" , "杨浩" , "刘伟" } set2 = { "刘伟" } res = set1.issuperset(set2) #set1是否是set2的父集 print (res) #简写 > res = set1 > set2 print (res) #True |
1 2 3 4 5 | isdisjoint() 检测两集合是否不相交 不相交为 True 相交为 False set1 = { "张恒" , "杨浩" , "刘伟" } set2 = { "刘伟" } res = set1.isdisjoint(set2) print (res) #False 相交 |
5.集合相关的函数
1 2 3 4 5 6 | add() 向集合中添加数据 update() 迭代着添加 clear() 清空集合 pop() 随机删除集合中的一个数据 remove() 删除集合中指定的值(不存在则报错) discard() 删除集合中指定的值(不存在的不删除 推荐使用) |
6.冰冻集合
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ''' forzenset 可强转容器类型数据变成冰冻集合 特征:冰冻集合一旦创建,不能再做任何的添加或者删除操作,只能做交叉并补 ''' #空的冰冻集合 fz = frozenset () print (fz, type (fz)) # frozenset() <class 'frozenset'> lst = [ 'a' , 'b' , 'c' ] fz = frozenset (lst) print (fz, type (fz)) #frozenset({'a', 'b', 'c'}) <class 'frozenset'> #只能做交叉并补 fz1 = frozenset ([ 'a' , 'b' , 'c' ]) fz2 = frozenset ([ 'a' , 'b' , 'c' , 'd' ]) res = fz1 & fz2 print (res) ##frozenset({'c', 'b', 'a'}) 里面元素顺序会变化 res = fz2 - fz1 print (res) ##frozenset({'d'}) #不能再冰冻集合中做任何修改原数据的操作 #fz1.add('s') #error |
7.文件操作
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 | #打开模式 w write 写入模式 文件不存在则创建,存在的话则打开清空内容,并且将文件指针放在文件的开头 r read 读取模式 文件不存在则报错。存在的话则打开文件,并且将文件指针放在文件的开头 a append 追加模式 文件不存在则创建文件,存在的话则打开文件,并且将文件指针放在文件的末尾 x xor 异或模式 文件已存在则报错 不存在的话则创建文件,将文件指针放在文件的开头 #拓展模式(配合打开模式的辅助模式,自己单独不使用) + plus 增强模式(可以让文件具有读写功能) b bytes bytes模式(二进制字节流) #模式一共16中 w,w + ,wb,wb + r,r + ,rb,rb + a,a + ,ab,ab + x,x + ,xb,xb + #将字符串和字节流(bytes)类型进行转换(参数写成转换的字符编码格式) #encode 将字符串转换成对应的二进制字节流 #decode 将字节流转换成字符串 语法:三步骤 #写入文件 1. 打开文件 fp = open ( '文件名或路径' , '模式' , '字符编码集' ) 2. 写入文件 fp,write(写入的内容) 3. 关闭文件 fp.close() #读取文件 1. 打开文件 fp = open ( '文件名或路径' , '模式' , '字符编码集' ) 2. 读取文件内容 res = fp.read() 3. 关闭文件 fp.close() |
总结:今天主要讲了列表相关函数的操作,深浅拷贝,字典的相关函数,集合中的交叉并补,集合中的相关函数,冰冻集合,文件的操作。
列表函数一共有以下几个:
# 改
append() 向列表的末尾添加新的元素
insert() 在指定索引之前插入元素
extend() 迭代追加所有元素
#删
pop() 指定索引删除元素,没有索引则默认删除最后一个元素
remove() 通过给与的值删除,如有多个相同元素,默认删除第一个
clear() 清空列表
#查
index() 获取某个值在列表中的索引
#计数
count() 计算某个元素出现的次数
#排序
sort() 列表排序默认从小到大,默认reverse = False
reverse() 列表反转
深浅拷贝:
浅拷贝:copy.copy(),只拷贝一级所有元素,一级元素改变,对应的copy过去的一级层级元素不变,是两个不同的地址。如果有二级层级元素,则沿用之前的。如果二级元素添加或删除一个元素,对应的copy过去的也会添加或删除同样的元素。
深拷贝:copy.deepcopy(),全部单独拷贝一份,其中不可变的数据类型暂时指向原数据,节省内存,可变的数据类型会单独开辟空间,如原数据二级层级改变的话,对应的拷贝过去的数据二级层级不会改变,因为是两个不同的内存空间。
字典函数:
#增
fromkeys() 可填两个参数,第一个参数为键(可填一组含有键的列表),第二个参数为值。 使用一组键和默认值创建字典,当值是可变的数据类型时,在可变的数据类型中添加数据,对应的其他键值对的值也会添加相应的值
#删
pop() 可填两个参数。第一参数为要删除的键,第二个参数可填返回的默认值。通过键去删除对应的键值对(若没有该键可设置默认值 预防报错)
popitem() 删除最后一个键值对,删除的键值对以元组的形式返回
clear() 清空字典
#改
update() 批量更新(有该键就更新 没有该键就添加)
#查
get() 可填两个参数,第一个参数为要获取的键,第二个参数为返回的默认值。通过键获取值(如没有该键可设置默认值 预防报错)
键和值以及键值对的获取:
keys() 将字典的键组成新的可迭代对象,可用for循环取值
values() 将字典中的值组成新的可迭代对象,可用fot循环取值
items() 将字典的键值对凑成一个个元组,组成新的可迭代对象,可用for循环取值
集合的相关操作:
intersection() 交集,共有的 简写 &
difference() 差集 我有的你没有,注意一下集合的前后顺序。简写 -
union() 并集 两个集合所有的元素包括共有的。简写 |
symmetric() 对称差集。除了交集以外的所有元素。简写 ^
issubset() 判断是否是子集、简写 <
issuperset() 判断是否是父集 >
isdisjoint() 检查两集合是否不相交。不相交返回True,相交返回False
集合的相关函数:
#增
add() 向集合增加数据
update() 迭代添加
#删
clear() 清空集合
pop() 随机删除集合中的一个数据
discard() 删除集合中指定的值,不存在的不删除。
remove() 删除集合中指定的值,不存在则报错。
冰冻集合:
frozenset() 只能用来做交叉并补,不能添加和删除。
文件操作:
open() 第一个参数为文件名或文件名所在路径,第二个参数打开模式,第三个参数字符编码集
以w模式写入文件步骤,打开文件,写入内容,关闭文件,以写模式打开文件时,文件不存在时会自动新建文件。
另外如果文件已经创建且有内容时,用写模式打开时,会清空文件内容,这边要注意。
以r模式读取文件步骤,打开文件,读取内容,关闭文件。
二进制字节流bytes,用来传输或存储数据,字符串和字节流之间的转换。
encode(字符编码格式) 编码,将字符串转换为字节流
decode(字符编码格式) 解码,将字节流转换为字符串
字节流的写入和读取分别用wb模式和rb模式,字节流模式下,不需要指定编码集
__EOF__

本文链接:https://www.cnblogs.com/weiweivip666/p/12864620.html
关于博主:可能又在睡觉
版权声明:转载请注明出处
声援博主:如果看到我睡觉请喊我去学习
-------------------------------------------
个性签名:代码过万,键盘敲烂!!!
如果觉得这篇文章对你有小小的帮助的话,记得在右下角点个“推荐”哦,博主在此感谢!
【推荐】国内首个AI IDE,深度理解中文开发场景,立即下载体验Trae
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· AI与.NET技术实操系列:向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列:如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
· 震惊!C++程序真的从main开始吗?99%的程序员都答错了
· winform 绘制太阳,地球,月球 运作规律
· 【硬核科普】Trae如何「偷看」你的代码?零基础破解AI编程运行原理
· 上周热点回顾(3.3-3.9)
· 超详细:普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人