列表相关函数，深浅拷贝，字典相关函数，集合相关操作及文件操作---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模式，字节流模式下，不需要指定编码集