python学习day8
- 列表的相关函数
-
- 增
-
- 1.append 在向列表末尾添加新元素
- 2.insert 在指定索引之前插入元素
- 3.extend 添加所有元素的迭代
- 删
-
- 1.pop 如果没有索引删除最后一个元素，则通过指定索引删除元素 (推荐)
- 2.remove 通过给予的值来删除,如果多个相同元素,默认删除第一个
- 3.clear 清空列表
- 改查
-
- index 在列表中获得一定值的索引
- count 计算某个元素出现的次数
- sort 列表排序(默认小到大排序)
- 排序字母 (字母排序依据ascii编码)
- 中文可以排序，但不规则可以遵循
- reverse 列表反转操作
- tuple 元组只有两个函数：count、 index 与列表中的方法完全相同
- 深拷贝 和 浅拷贝
-
- (1) 浅拷贝 (只复制一级容器的所有元素，其他层次延续以前的数据)
-
- 方法一
- 方法二 (推荐)
- (2) 深拷贝 (各级元素单独复制一份，形成独立副本)
- (3) 总结：copy 和 deepcopy 谁更快 浅拷贝更快~
- 字典相关函数
-
- 增 fromkeys()
- 删
-
- pop() 按键删除键值对 (如果没有此键，可以设置默认值，防止报错)**
- popitem() 删除最后一个键值对
- clear() 清空字典
- 改
-
- update() 批量更新 (有键就更新，没键就加)
- 查
-
- get() 通过键获取值(如果没有键，可以设置默认值，防止报错)
- 重点语法：
-
- keys() 将字典键组成新的可迭代对象
- values() 将字典中的值组成新的可迭代对象
- items() 将字典的键值对合成一个元组，形成新的可迭代对象
-
- items()解包变量
- 集合相关操作 (交叉并补)
-
- 1.intersection() 交集，简写为：&
- 2.difference() 差集，简写为：-
- 3.union() 并集，简写为：|
- 4.symmetric_difference() 对称差集 (其中包充) 简写为：^
- issubset() 判断是否是子集，简写为：<
- issuperset() 判断是否是父集，简写为：>
- isdisjoint() 检测两集是否不相交 不相交 True 相交False
- 收集相关函数
-
- 增
-
- add() 向集合中添加数据 (一次加一个)
- update() 迭代着增加 (一次加一堆)
- 删
-
- clear() 清空集合
- pop() 随机删除集合中的数据
- discard() 删除集合中指定的值(未删除) 推荐使用)
- remove() 删除集合中指定的值(不存在则报错)(理解)
- 冰冻集合(理解)
-
- 空冰冻集合
- 冰冻集合可遍历
- 只能交叉补
- 文件操作
-
- 1.文件的写入操作
- 2.读取文件的操作
- 3.转换字节流
- 4.存储字节流
- 5.读取字节流
- 复制文件夹 集合.png 这张图片
- 2.将所有读出的二进制字节流写入另一份文件
列表的相关函数
增
1.append 在向列表末尾添加新元素
lst = ["黄俊"] lst.append("王振") print(lst) # ["黄俊","王振"] 2.insert 在指定索引之前插入元素
lst = ['黄俊', '王振'] lst.insert(1,"刘伟") print(lst) # 黄军，刘伟 3.extend 添加所有元素的迭代
lst = ['黄俊', '王振']
tup = ("宋普东","王赢钱","陈宁波")
lst.extend(tup)
print(lst) # ['黄俊','王振','宋普东','王赢钱','陈宁波']
删
1.pop 通过指定索引删除元素,若没有索引移除最后那个 (推荐)
lst = ["魏富强","宋清零","黎建忠","朱家熠"]
res = lst.pop()
print(res) # "朱家熠"
print(lst) # ["魏富强","宋清零","黎建忠"]
lst = ["魏富强","宋清零","黎建忠","朱家熠"]
res = lst.pop(1)
print(res) # '宋清零'
print(lst) # ["魏富强","黎建忠","朱家熠"]
2.remove 通过给予的值来删除,如果多个相同元素,默认删除第一个
lst = ["魏富强","宋清零","黎建忠","黎建忠","朱家熠"]
lst.remove("黎建忠")
print(lst) # ["魏富强","宋清零","黎建忠","朱家熠"]
3.clear 清空列表
lst = ["魏富强","宋清零","黎建忠","朱家熠"]
lst.clear()
print(lst) # []
改查
index 获取某个值在列表中的索引
lst = ["魏富强","宋清零","黎建忠","朱家熠","魏富强","魏富强"]
res = lst.index("宋清零") # 1
# res = lst.index("宋清零123") # error
print(res)
count 计算某个元素出现的次数
lst = ["魏富强","宋清零","黎建忠","朱家熠","魏富强","魏富强"]
res = lst.count("魏富强")
print(res) # 3
sort 列表排序(默认小到大排序)
lst = [100,200,90,-3,0,12]
lst.sort()
print(lst) # [-3, 0, 12, 90, 100, 200]
lst = [100,200,90,-3,0,12]
lst.sort(reverse = True)
print(lst) # [200, 100, 90, 12, 0, -3]
对字母进行排序 (字母排序依照ascii编码)
lst = ["kobe","james","oneal","jordon","iverson"]
lst.sort()
print(lst) # ['iverson', 'james', 'jordon', 'kobe', 'oneal']
可以对中文进行排序,但是无规律可循
lst = ["王闻","周杰伦","罗志祥","蔡徐坤","王振"]
lst.sort()
print(lst) # ['周杰伦', '王振', '王闻', '罗志祥', '蔡徐坤']
reverse 列表反转操作
lst = [100 ,200,300,-3]
lst.reverse()
print(lst) # [-3, 300, 200, 100]
tuple 元组中的函数只有2个：count、 index 跟列表中的方法使用一模一样
tup = (1,2,3,4,[5,6,7])
tup[-1].append(8)
print(tup) # (1, 2, 3, 4, [5, 6, 7, 8])
tup = (1,2,3,[4,5,6,(7,8,9)])
tup[-1][-1] = 100 # 将列表中的元组(7,8,9)这个元素改为100
print(tup) # (1, 2, 3, [4, 5, 6, 100])
深拷贝 和 浅拷贝
a = 19
b = a
print(id(b),id(a)) # 双方id相同
a = 20
print(b) # 19 # 变更了a的赋值，b不变
lst1 = [1,2,3]
lst2 = lst1
lst1.append(4) # 变更了lst1的赋值
print(lst2) # lst2也跟着变了
(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]))
print( id(lst2[0])) # 对应元素的值不同，双方id不同，反之则相同
方法二 (推荐)
copy模块.copy函数()
import copy
lst = [1,2,3]
lst2 = copy.copy(lst)
lst.append(10)
print(lst)
print(lst2)
(2) 深拷贝 (所有层级的元素都单独拷贝一份,形成独立的副本)
import copy
lst = [1,2,3,[4,5,6]]
lst2 = copy.deepcopy(lst)
lst[-1].append(888)
print(lst) # [1, 2, 3, [4, 5, 6, 888]]
print(lst2) # [1, 2, 3, [4, 5, 6]]
print(id(lst[-1]) , id(lst2[-1])) # 不相同
import copy
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]}
(3) 总结：copy 和 deepcopy 谁更快 浅拷贝更快~
字典相关函数
增 fromkeys()
dic = {
}
dic["top"] = "韩国the shy"
dic["middle"] = "肉鸡rookie"
dic["bottom"] = "a_water"
dic["jungle"] = "鞋王"
dic["support"] = "bao_blue"
print(dic)
lst = ["a","b","c"]
dic = {
}.fromkeys(lst,None) # 将列表所有元素转换成键
print(dic)
lst = ["a","b","c"]
dic2 = {
}.fromkeys(lst,[1,2]) # 将列表所有元素转换成键，并统一赋予对应值[1,2]
dic2["a"].append(3) # 给键'a'对应的列表增加元素3，别的键对应的列表也都增加了元素3
print(dic2) # {'a': [1, 2, 3], 'b': [1, 2, 3], 'c': [1, 2, 3]}
dic3 = {
}
dic3["a"] = [1,2]
dic3["b"] = [1,2]
dic3["c"] = [1,2]
dic3["a"].append(3) # 只给键a对应的列表增加了元素3
print(dic3) # {'a': [1, 2, 3], 'b': [1, 2], 'c': [1, 2]}
删
pop() 通过键去删除键值对 (若没有该键可设置默认值,预防报错)**
dic = {
'top': '韩国the shy', 'middle': '肉鸡rookie', 'bottom': 'a_water', 'jungle': '鞋王', 'support': 'bao_blue'}
res = dic.pop("bottom")
print(res) # a_water 返回的是被删除的键对应的值
print(dic) # {'top': '韩国the shy', 'middle': '肉鸡rookie', 'jungle': '鞋王', 'support': 'bao_blue'}
dic = {
'top': '韩国the shy', 'middle': '肉鸡rookie', 'bottom': 'a_water', 'jungle': '鞋王', 'support': 'bao_blue'}
res = dic.pop("bottom123","没有")
print(res) # 没有 没有对应值，返回设置的默认值
popitem() 删除最后一个键值对
dic = {
'top': '韩国the shy', 'middle': '肉鸡rookie', 'bottom': 'a_water', 'jungle': '鞋王', 'support': 'bao_blue'}
res = dic.popitem()
print(dic) # {'top': '韩国the shy', 'middle': '肉鸡rookie', 'bottom': 'a_water', 'jungle': '鞋王'}
print(res) # ('support', 'bao_blue') 返回的是被删除的键值对
clear() 清空字典
dic = {
'top': '韩国the shy', 'middle': '肉鸡rookie', 'bottom': 'a_water', 'jungle': '鞋王', 'support': 'bao_blue'}
dic.clear()
print(dic) # {}
改
update() 批量更新 (有该键就更新,没该键就添加)
dic = {
"ww":"大帅哥","spd":"渣男","sql":"负心男"}
newdic = {
"ww":"美男子","wz":"一表人才","yh":"未来的土豪"}
dic.update(newdic)
print(dic) # {'ww': '美男子', 'spd': '渣男', 'sql': '负心男', 'wz': '一表人才', 'yh': '未来的土豪'}
dic = {
"ww":"大帅哥","spd":"渣男","sql":"负心男"}
dic.update(hj="未来战士",wyq="警察") # 括号中输入键值对时，用等号连接键值对
print(dic) # {'ww': '大帅哥', 'spd': '渣男', 'sql': '负心男', 'hj': '未来战士', 'wyq': '警察'}
查
get() 通过键获取值(若没有该键可设置默认值,预防报错)
dic = {
"ww":"大帅哥","spd":"渣男","sql":"负心男"}
# res = dic["www"]
res = dic.get("www") # 返回None
dic = {
"ww":"大帅哥","spd":"渣男","sql":"负心男"}
res = dic.get("www","该键不存在")
print(res) # 该键不存在
重点语法：
keys() 将字典的键组成新的可迭代对象
dic = {
"wy":"智多星","lzs":"花和尚","zs":"浪里白条"}
res = dic.keys()
print(res) # dict_keys(['wy', 'lzs', 'zs'])
values() 将字典中的值组成新的可迭代对象
dic = {
"wy":"智多星","lzs":"花和尚","zs":"浪里白条"}
res = dic.values()
print(res) # dict_values(['智多星', '花和尚', '浪里白条'])
items() 将字典的键值对凑成一个个元组,组成新的可迭代对象
dic = {
"wy":"智多星","lzs":"花和尚","zs":"浪里白条"}
res = dic.items()
print(res) # dict_items([('wy', '智多星'), ('lzs', '花和尚'), ('zs', '浪里白条')])
items()的变量的解包
dic = {
"wy":"智多星","lzs":"花和尚","zs":"浪里白条"}
res = dic.items()
for k,v in res:
print(k,v)
''' 输出为： wy 智多星 lzs 花和尚 zs 浪里白条 '''
集合的相关操作 (交叉并补)
1.intersection() 交集，简写为：&
set1 = {
"the shy" , "rookie" , "jacklove" , "神秘男孩"}
set2 = {
"蔡国庆","倪萍","赵忠祥","神秘男孩"}
res = set1.intersection(set2)
print(res) # {'神秘男孩'}
# 简写 &
res = set1 & set2
print(res)
2.difference() 差集，简写为：-
set1 = {
"the shy" , "rookie" , "jacklove" , "神秘男孩"}
set2 = {
"蔡国庆","倪萍","赵忠祥","神秘男孩"}
res = set1.difference(set2)
print(res) # {'rookie', 'jacklove', 'the shy'}
# 简写 -
res = set1 - set2
print(res)
3.union() 并集，简写为：|
set1 = {
"the shy" , "rookie" , "jacklove" , "神秘男孩"}
set2 = {
"蔡国庆","倪萍","赵忠祥","神秘男孩"}
res = set1.union(set2) # {'神秘男孩', 'the shy', '蔡国庆', '倪萍', '赵忠祥', 'rookie', 'jacklove'}
print(res)
# 简写 |
res = set1 | set2
print(res)
4.symmetric_difference() 对称差集 (补集情况涵盖在其中) 简写为：^
set1 = {
"the shy" , "rookie" , "jacklove" , "神秘男孩"}
set2 = {
"蔡国庆","倪萍","赵忠祥","神秘男孩"}
res = set1.symmetric_difference(set2)
print(res) # {'赵忠祥', '蔡国庆', 'the shy', 'rookie', '倪萍', 'jacklove'}
## 简写 ^
res = set1 ^ set2
print(res)
issubset() 判断是否是子集，简写为：<
set1 = {
"张恒","杨