列表、元组、字典、集合的基本使用和相关函数，基础的文件操作

2、列表的相关函数

append、insert、extend、pop、remove、clear、index、count、sort、reverse、del

（1）增：有三个方法

• append 向列表末尾添加新的元素
• insert 向指定索引前添加新的元素，必须设置参数，否则会报错；当插入的列表为空时，参数为0也可执行插入操作
• extend 迭代追加所有元素（迭代追加字典类型只会获取到键添加进去）

（2）删：有4个方法

• pop 通过索引删除指定元素（无参数默认删除最后一个，可获取已删元素内容）；注：删除元素后列表的索引会发生变化
• remove 通过赋予的值来删除，如果有多个，默认删除第一个（不可获取已删元素内容）；不可同时删除多个，删除的元素不在列表中时程序报错，无默认删除使用remove必须设置参数
• clear 清空列表，清除所有元素
• del 可一次性删除多个

（3）改、查和排序

• index 获取列表中值的索引
• count 获取列表中某个元素的数量
• sort 列表排序，对数字排序，默认从小到大，可使用参数 reverse = True；对字母排序，根据ASCII码表编码进行比较；可以对中文进行排序，但是无规律可循。注：当出现数字字符串，字母字符串，文字字符串混合时会出现特殊情况：数字字符串永远在 > 字母字符串 > 文字字符串
• reverse 列表反转，就是反转，从后往前调换

# append
listvar = ['asd']
listvar.append('zsd')
listvar.append(['pas'])
listvar.append(('ple'))
listvar.append({'plp'})
listvar.append({'a': 'b'})
listvar.append(1)
print(listvar)

# insert
listvar = ['asd']
listvar.insert(1, 'pdd')
listvar.insert(1, ['pas'])
listvar.insert(1, ('ple'))
listvar.insert(1, {'plp'})
listvar.insert(1, {'a': 'b'})
listvar.insert(1, 1)
print(listvar)

# extend
listvar = ['asd']
tup1 = ['a', 'b', 'c']
tup2 = ('a', 'b', 'c')
tup3 = {'a', 'b', 'c'}
tup4 = {'a': 'b', 'd': 'd'}
tup5 = 'asd'
listvar.extend(tup5)
print(listvar)

# pop
lst = ['阿凡达', '阿迪达斯', '史莱姆']
res = lst.pop()
ret = lst.pop(1)
print(res, ret, lst)

# remove
lst = ['阿凡达', '阿迪达斯', '史莱姆']
lst.remove('阿凡达')
lst.remove('阿迪达斯')
print(lst)

# clear
lst = ['阿凡达', '阿迪达斯', '史莱姆']
lst.clear()
print(lst)

# index
lst = ['阿凡达', '阿迪达斯', '史莱姆']
ret1 = lst.index('阿迪达斯')
ret2 = lst.index('阿凡达')
print(ret1, ret2)

# count
lst = ['阿凡达', '阿迪达斯', '史莱姆', '阿迪达斯', '阿迪达斯',]
ret = lst.count('阿迪达斯')
print(ret)

# sort：纯数字
lst = [100, 20, -1, -30, 0, 10]
lst.sort()
lst.sort(reverse=True)
print(lst)

# sort：纯字母
lst = ['part', 'nepenthe', 'forget', 'me', 'not']
lst.sort()
print(lst)

# sort：数字字符串，字母字符串，文字字符串混合使用时：数字字符串>字母字符串>文字字符串
lst = ['王闻', '周杰伦', '罗志祥', 'me', 'not', 'afas', '12', '2', '30']
lst.sort()
print(lst)

# reverse列表反转，就是反转，从后往前调换
lst = [100, 20, -1, -30, 0, 10]
lst.reverse()
print(lst)

3、深浅拷贝

浅拷贝和深拷贝

# 未使用深浅拷贝的状态
lst1 = [1, 2, 3]
lst2 = lst1
lst1.append(4)
print(lst2)

浅拷贝：

​ 方法一：copy方法只针对列表

# copy()
lst = [1, 2, 3]
lst2 = lst.copy()
lst.append(5)
print(lst)
print(lst2)

​ 方法二：引入模块，copy.copy(任意类型)

​ 浅拷贝只拷贝一级所有的元素

# copy.copy()
import copy
lst = [1, 2, 3]
lst2 = copy.copy(lst)
lst.append(5)
print(lst)
print(lst2)

深拷贝：

​ 引入copy模块，使用copy.deepcopy()可将所有层级的元素都拷贝一份，不会被拷贝之前的数据影响，单独开辟的空间；copy和deepcopy，copy更快一些，也就是浅拷贝效率高；深拷贝也可以应用在字典中

​ （地址：原来不可变只是暂时的指向，可变的数据独立的开辟空间）

import copy
lst = [1, 2, 3, [4, 5, 6]]
lst2 = copy.deepcopy(lst)
lst[-1].append(7)
print(lst)
print(lst2)

4、元组

特点：可查询，不可修改，有序

元组只有两个函数：count和 index，和列表中的使用方式相同

八、字典

1、字典相关函数

fromkeys、append、pop、popitem、clear、update、get、key、values、items

（1）增：三种方式（实质上是两种，append是列表的方法）

• 直接定义赋值：直接使用类似 dic[‘dic’]=‘dic’ 的方式

• fromkeys：使用一组键和默认值创建字典，注：添加值的时候会自动给所有键对应的值都添加上

• append：要先创建一个未赋值的键值对并且值是一个列表，才可使用append进行赋值操作，否则将会报错

（2）删：有三个方法

• pop：通过键删除键值对（可设置默认值，避免删除的键值对不存在时报错），可以字符串的形式获取到删除的键值对
• popitem：删除最后一个键值对，可以元组的形式获取到删除的键值对；空字典会报错
• clear：清空字典，只剩一组括号

（3）改

• update：可批量更新（当出现不存在的键值对时会默认添加进去）

  有三种书写方式：直接在update中写入字典；先定义字典一个字典，再在update中传入定义的字典；通过

  键=值 的方式直接写入update中

（4）查：四个方法

• get：通过键获取值，当没有获取到的键会返回None，也可设置默认值（未获取到键就返回设置的默认值）
• key：将字典的键组成新的可迭代对象，注：组成的新的可迭代对象的数据类型不是list列表，而是dict_keys数据类型
• values：将字典的值组成新的可迭代对象，注：组成的新的可迭代对象的数据类型不是list列表，而是dict_values数据类型
• items：将字典的键值对凑成一个个元组，组成新的可迭代对象，注：组成的新的可迭代对象的数据类型不是tuple元组，而是dict_values数据类型

# 直接定义赋值
dic = {}
dic['alex'] = 'old boy'
dic['xboyww'] = 'young boy'
print(dic)

# fromkeys
lst = ['a', 'b', 'c']
dic = {}.fromkeys(lst, [1, 2, 3])
dic = {}.fromkeys(lst, None)
print(dic)

lst = ['a', 'b', 'c']
dic = {}.fromkeys(lst, [1, 2, 3])
dic['a'].append(4)
print(dic)

# append 只针对值是列表的类型
dic = {}
dic["a"] = []
dic["b"] = []
dic["a"].append(1)
dic['b'].append(2)
print(dic)

# pop
dic = {'alex': 'good', 'ww': 'very good', 'top': 'all fake'}
ret = dic.pop('top')
rets = dic.pop('down', '无此键值对')
print(type(ret), dic, type(rets))

# popitem
dic = {'alex': 'good', 'ww': 'very good', 'top': 'all fake'}
res = dic.popitem()
print(type(res), dic)

# clear
dic = {'alex': 'good', 'ww': 'very good', 'top': 'all fake'}
dic.clear()
print(dic, type(dic))

# update 第一种写法
dic = {'alex': 'good', 'ww': 'very good', 'top': 'all fake'}
dic.update({'top': 'all right'})
dic.update({'down': 'all right', 'downs': 'all right'})
dics = {'down': 'all right', 'downs': 'all right'}
dic.update(dic)
print(dic)

# update 第二种写法
dic = {'alex': 'good', 'ww': 'very good', 'top': 'all fake'}
dic.update(top='all right', down='all right')
print(dic)

# get
dic = {'alex': 'good', 'ww': 'very good', 'top': 'all fake'}
ret = dic.get('top')
res = dic.get('tops')
rets = dic.get('tops', '此键不存在')
print(ret, res, rets)

# keys
dic = {'alex': 'good', 'ww': 'very good', 'top': 'all fake'}
ret = dic.keys()
print(ret, type(ret))

# values
dic = {'alex': 'good', 'ww': 'very good', 'top': 'all fake'}
res = dic.values()
print(res, type(res))
dic = {'alex': 'good', 'ww': 'very good', 'top': 'all fake'}
ret = dic.items()
print(ret, type(ret))

# 变量的解包
for k, v in ret:
    print(k, v)

九、集合

1、集合的相关操作（交叉并补）

交集、差集、并集、对称差集、补集（包含关系才有补集）、

（1）交集 intersection（）简写 &

（2）差集 difference（）简写 -

（3）并集 union（）简写 |

（4）对称差集 symmetric_difference（）简写 ^ （包含补集的情况）

（5）子集 issubset（）简写 <

（6）父集 issuperset（）简写 >

（7）isdisjoint（）检测两个集合是否不相交 不相交返回True，相交False

# 交集
lset1 = {'a', 'b', 'c', 'all fake'}
lset2 = {'good', 'very good', 'all fake'}
ret1 = lset1 & lset2
ret2 = lset1.intersection(lset2)
print(ret1)
print(ret2)

# 差集
lset1 = {'a', 'b', 'c', 'all fake'}
lset2 = {'good', 'very good', 'all fake'}
ret1 = lset1 - lset2
ret2 = lset1.difference(lset2)
print(ret1)
print(ret2)

# 并集
lset1 = {'a', 'b', 'c', 'all fake'}
lset2 = {'good', 'very good', 'all fake'}
ret1 = lset1 | lset2
ret2 = lset1.union(lset2)
print(ret1)
print(ret2)

# 对称差集
lset1 = {'a', 'b', 'c', 'all fake'}
lset2 = {'good', 'very good', 'all fake'}
ret1 = lset1 ^ lset2
ret2 = lset1.symmetric_difference(lset2)
print(ret1)
print(ret2)

# 子集
lset1 = {'a', 'b', 'c', 'all fake'}
lset2 = {'good', 'very good', 'all fake'}
ret1 = lset1 < lset2
ret2 = lset1.issubset(lset2)
print(ret1)
print(ret2)

# 父集
lset1 = {'a', 'b', 'c', 'all fake'}
lset2 = {'good', 'very good', 'all fake'}
ret1 = lset1 > lset2
ret2 = lset1.issuperset(lset2)
print(ret1)
print(ret2)

#检测两个集合是否不相交
lset1 = {'a', 'b', 'c', 'all fake'}
lset2 = {'good', 'very good', 'all fake'}
ret2 = lset1.isdisjoint(lset2)
print(ret1)
print(ret2)

2、集合相关的函数

add、update（迭代增加）、clear、pop（集合中随机删除）、remove()、discard()

（1）增：有两个方法

• add：单个添加
• update：迭代增加，多个添加 ；注：update中是字符串的时候，字符串会被拆分成单个字符

（2）删：有四个方法

• clear：清空集合中的所有数据

• pop：随机删除集合中的一个数据

• remove：删除集合中的指定的值（不存在会报错）

• discard：删除集合中的指定的值（不存在不会报错，不会删除，推荐使用）

  # add 
  setvar = {'zxc'}
  setvar.add("asd")
  print(setvar)
  
  # update
  setvar = {'zxc'}
  setvar.update("asd", 'pdd', 'lq')
  lst = ['azx', 'qwe']
  setvar.update(lst)
  tup = ['azx', 'qwe']
  setvar.update(tup)
  strs = 'apd'
  setvar.update(strs)
  print(setvar)
  
  # clear
  setvar = {"asd", 'pdd', 'lq'}
  setvar.clear()
  print(setvar)
  
  # pop
  setvar = {"asd", 'pdd', 'lq'}
  setvar.pop()
  print(setvar)
  
  # discard
  setvar = {"asd", 'pdd', 'lq'}
  setvar.discard('pdd')
  setvar.discard('pdds')
  print(setvar)
  
  # remove
  setvar = {"asd", 'pdd', 'lq'}
  setvar.remove('pdd')
  # setvar.remove('pdds')
  print(setvar)
  

冰冻集合：frozenset 可强转容器类型数据变成冰冻集合
特征:冰冻集合一旦创建,不能再做任何的添加或者删除操作,只能做交叉并补，可以遍历

fz = frozenset()
print(fz, type(fz))

lst = ["a", "b", "c"]
fz = frozenset(lst)
print(fz, type(fz))
for i in fz:
    print(i)

fz1 = frozenset(["a","b","c"])
fz2 = frozenset(["a","b","c","d"])
res = fz1 & fz2
res = fz2 - fz1
print(res)

十、文件操作

1、文件的基本操作

打开文件open(‘文件名’, ‘模式’, ‘字符编码集’)；关闭文件 fp.close()

（1）文件的写入操作：mode = ‘w’（write）模式；write（）方法写入内容

（2）文件的读取操作：mode = ‘r’（read）模式；read（）方法读取内容

（3）字节流的转换：

​ encode（）编码，将字符串转化为二进制字节流

​ decode（）解码，将二进制字节流转化为字符串

（4）字节流的存储：字节流模式下，无需指定编码集

​ 写入操作：mode = ‘wb’ ；读取操作：mode = ‘rb’

# 文件的写入操作
fp = open("ceshi.txt", mode='w', encoding="utf-8")
fp.write("把大象塞进去")
fp.close()

# 文件的读取操作
fp = open("ceshi.txt", mode='r', encoding="utf-8")
ret = fp.read()
print(ret)
fp.close()

# 字节流的转换
strvar = '我爱你'
res = strvar.encode('utf-8')  # 编码
print(res)
ret = b'\xe6\x88\x91\xe7\x88\xb1\xe4\xbd\xa0'.decode('utf-8')  # 解码
print(ret)

# 字节流写入操作
fp = open("ceshi2.txt", mode="wb")
str_bytes = "Trouble is a friend".encode("utf-8")
fp.write(str_bytes)
fp.close()

# 字节流读取操作
fp = open("ceshi2.txt",mode="rb")
res = fp.read()
fp.close()

# 图片 音频 视频这样的文件都是二进制bytes，图片的读写操作如下
fp = open('GD5.jpg', mode='rb')
GD_bytes = fp.read()
fp.close()
print(GD_bytes)

fp = open('GD6.jpg', mode='wb')
fp.write(GD_bytes)
fp.close()