列表相关函数,深浅拷贝,字典相关函数,集合相关操作及文件操作---day08
1.列表的相关函数
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 注意:直接更改原列表
注意:对字母进行排序字母排序依据ascii编码,字母是一位一位的进行比较,如果第一位相同再去比较第二位依次类推。
另外可以对中文进行排序,但是无规律可循
2.浅拷贝和深拷贝
copy模块中有 浅拷贝 和 深拷贝两种方法 (1)浅拷贝:浅拷贝只拷贝外层列表,内层列表跟随原列表进行改变 浅拷贝copy.copy(listvar)或listvar.copy() (2)深拷贝:拷贝整个列表 内外列表都不跟随原列表进行改变 深拷贝copy.deepcopy(listvar) 注意:copy模块的copy方法和python内置的函数copy一样,都是浅拷贝
# ### 深拷贝 和 浅拷贝 ''' 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.字典的相关函数
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创建键值对时,如值是可变的数据类型时, #在可变的列表中添加数据,对应的其他键值对的值也会同样添加相应的值
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)
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') 删除的键值对以元组形式返回
clear() 清空字典 dic.clear() print(dic)
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)
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)
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循环取值
#变量的解包 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.集合中的交差并补
intersection() 交集 共有的 set1 = {"the shy" , "rookie" , "jacklove" , "神秘男孩"} set2 = {"蔡国庆","倪萍","赵忠祥","神秘男孩"} res = set1.intersection(set2) print(res) #{'神秘男孩'} #简写 & res = set1 & set2 print(res) #{'神秘男孩'}
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'}
union() 并集,两个集合中所有元素包括共有的元素 集合自带去重 set1 = {"the shy" , "rookie" , "jacklove" , "神秘男孩"} set2 = {"蔡国庆","倪萍","赵忠祥","神秘男孩"} res = set1.union(set2) print(res) #{'the shy', '神秘男孩', '倪萍', '赵忠祥', 'rookie', 'jacklove', '蔡国庆'} #简写 | res = set1 | set2 print(res)
symmetric_difference() 对称差集(补集情况涵盖其中) #可以理解为除了交集以外的所有元素 set1 = {"the shy" , "rookie" , "jacklove" , "神秘男孩"} set2 = {"蔡国庆","倪萍","赵忠祥","神秘男孩"} res = set1.symmetric_difference(set2) print(res) #{'赵忠祥', '倪萍', 'rookie', '蔡国庆', 'the shy', 'jacklove'} #简写 ^ res = set1 ^ set2 print(res)
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
issuperset() 判断是否是父集 set1 = {"张恒","杨浩","刘伟"} set2 = {"刘伟"} res = set1.issuperset(set2) #set1是否是set2的父集 print(res) #简写 > res = set1 > set2 print(res) #True
isdisjoint() 检测两集合是否不相交 不相交为True 相交为False set1 = {"张恒","杨浩","刘伟"} set2 = {"刘伟"} res = set1.isdisjoint(set2) print(res) #False 相交
5.集合相关的函数
add() 向集合中添加数据 update() 迭代着添加 clear() 清空集合 pop() 随机删除集合中的一个数据 remove() 删除集合中指定的值(不存在则报错) discard() 删除集合中指定的值(不存在的不删除 推荐使用)
6.冰冻集合
''' 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.文件操作
#打开模式 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模式,字节流模式下,不需要指定编码集
-------------------------------------------
个性签名:代码过万,键盘敲烂!!!
如果觉得这篇文章对你有小小的帮助的话,记得在右下角点个“推荐”哦,博主在此感谢!