列表相关函数，深浅拷贝，字典相关函数，集合相关操作及文件操作

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编码，字母是一位一位的进行比较，如果第一位相同再去比较第二位依次类推。
另外可以对中文进行排序，但是无规律可循

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的二级层级不改变
#因为都是单独独立的空间

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 浪里白条
‘‘‘

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 相交

add()   向集合中添加数据
update()  迭代着添加
clear()   清空集合
pop()   随机删除集合中的一个数据
remove()   删除集合中指定的值(不存在则报错)
discard()  删除集合中指定的值(不存在的不删除 推荐使用)

‘‘‘
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

#打开模式
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()