文章目录
字符串的格式化 format
format：相当于占位符。
顺序传参、索引传参、关键字传参、容器类型传参（列表和元组）
# 顺序传参
strvar = '{}向{}开了一枪，饮弹而亡'
res = strvar.format('ys','恶魔')
print(res) # ys向恶魔开了一枪，饮弹而亡
# 索引传参
strvar = '{1}向{0}开了一枪，饮弹而亡'
res = strvar.format('ys','恶魔')
print(res) # 恶魔向ys开了一枪，饮弹而亡
# 关键字传参
strvar = '{who1}向{who2}开了一枪，饮弹而亡'
res = strvar.format(who1='ys',who2='恶魔')
print(res) # ys向恶魔开了一枪，饮弹而亡
# 容器类型传参
# 情况一
strvar = '{0[1]}向{1[0]}开了一枪，饮弹而亡'
res = strvar.format(['ys','ymt'],('恶魔','魔鬼'))
print(res) # ymt向恶魔开了一枪，饮弹而亡
# 情况二 format格式化时，要注意如果是字典，不要加引号
strvar = '{0[1]}向{1[b]}开了一枪，饮弹而亡'
res = strvar.format(['ys','ymt'],{'a':'恶魔','b':'魔鬼'})
print(res) # ymt向魔鬼开了一枪，饮弹而亡
关键字 pass / break / continue
# pass 过 起到占位的作用
if 5==5:
pass
# break 只能应用在循环当中，用于终止当前循环
# 打印1~10 遇到5终止循环
i = 1
while i<=10:
if i == 5:
break
print(i)
i+=1
# break在第二层循环里
i = 1
while i<=3:
j = 1
while j<=3:
print(i,j)
if j == 2:
break # 终止当前所在的循环
j+=1
i+=1
# continue 跳过当前循环，从下一次循环开始
# 打印1~10 不打印5
i = 1
while i<=10:
if i == 5:
i+=1
continue # 此处有坑
print(i)
i+=1
# 打印1~100 不含有4的数
# 方法一
i = 1
while i<=100:
if '4' in str(i):
i+=1
continue
print(i)
i+=1
# 方法二
i = 1
while i<=100:
if i // 10 == 4 or i % 10 == 4:
i+=1
continue
print(i)
i+=1
列表的相关操作
列表的拼接
lst1 = [1,2,3]
lst2 = [4,5,6]
res = lst1 + lst2
print(res) # [1, 2, 3, 4, 5, 6]
列表的重复
lst1 = [7,8,9]
res = lst1 * 3
print(res) # [7, 8, 9, 7, 8, 9, 7, 8, 9]
列表的切片
'''
语法 => 列表[::] 完整格式：[开始索引:结束索引:间隔值]
(1)[开始索引:] 从开始索引截取到列表的最后
(2)[:结束索引] 从开头截取到结束索引之前(结束索引-1)
(3)[开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1)
(4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
(5)[:]或[::] 截取所有列表
'''
listvar = [1,2,3,4,5,6,7,8,9]
# (1)[开始索引:] 从开始索引截取到列表的最后
res = listvar[1:]
print(res) # [2, 3, 4, 5, 6, 7, 8, 9]
# (2)[:结束索引] 从开头截取到结束索引之前(结束索引-1)
res = listvar[:4] # 高位取不到
print(res) # [1, 2, 3, 4]
# (3)[开始索引:结束索引]
res = listvar[3:7]
print(res) # [4, 5, 6, 7]
# (4)[开始索引:结束索引:间隔值]
# 0 3 6 9 先把数字数出来 通过下标找对应值
res = listvar[::3]
print(res) # [1, 4, 7]
# 3 5 7 9
print(listvar[3::2]) # [4, 6, 8]
# 0 3 6 9
print(listvar[:6:3]) # [1, 4]
# 倒序
print(listvar[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1]
# -2 -4
print(listvar[-2:-6:-2]) # [8, 6]
列表的获取
# 0 1 2
listvar = ["a","b","c"]
# -3 -2 -1
res = listvar[2]
print(res) # c
res = listvar[-1]
print(res) # c
列表的修改（可切片）
listvar = ['a','b','c','d']
listvar[3] = '123'
print(listvar) # ['a', 'b', 'c', '123']
# 如果使用了切片进行修改，右侧必须是可迭代性数据
listvar[2:] = '123'
print(listvar) # ['a', 'b', '1', '2', '3']
listvar[2:] = range(0,4)
print(listvar) # ['a', 'b', 0, 1, 2, 3]
# 如果使用了切片，并且指定了第三个参数间隔值
# 那么截取几个就放几个，一一对应
listvar = ['a','b','c','d']
listvar[::2] = (1,2)
print(listvar) # [1, 'b', 2, 'd']
列表的删除（可切片）
listvar = ['a','b','c','d']
del listvar[1]
print(listvar) # ['a', 'c', 'd']
# 可以使用切片删除
listvar = ['a','b','c','d']
del listvar[1:3]
print(listvar) # ['a', 'd']
# 元组当中的一级数据更改不了，但是二级或者多级如果是列表这样的数据可修改
tup = (1,2,3,4,5,[1,2,3,45])
tup[-1][-1] = 54
print(tup) # (1,2,3,4,5,[1,2,3,54])
列表的方法
append
# append
'''
功能：向列表的末尾添加新的元素
格式：列表.append(值)
返回值：None
注意：新添加的值在列表的末尾，该函数直接操作原有列表
'''
listvar = [1,2,3,4,5]
listvar.append(6)
print(listvar) # [1, 2, 3, 4, 5, 6]
listvar.append([12,3])
print(listvar) # [1, 2, 3, 4, 5, [12, 3]]
insert()
'''
功能：在指定索引之前插入元素
格式：列表.insert(索引,值)
返回值:None
注意：直接改变原有列表
'''
listvar = [1,2,3,4,5]
listvar.insert(2,"7")
print(listvar) # [1, 2, '7', 3, 4, 5]
entend()
'''
功能：迭代追加所有元素
格式：列表.extend(可迭代性数据)
返回值：None
注意：直接改变原有列表
'''
listvar = [1,2,3,4,5]
listvar.extend(['1','2'])
# listvar.extend({'a':1,"b":2}) 语法上允许
print(listvar) # [1, 2, 3, 4, 5, '1', '2']
pop
'''
功能：通过指定索引删除元素,若没有索引移除最后那个
格式：列表.pop(索引)
返回值：删除的元素
(注意：没有指定索引，默认移除最后一个元素 )
'''
listvar = [1,2,3,4,5]
res = listvar.pop()
print(res) # 5
print(listvar) # [1,2,3,4]
res = listvar.pop(3) # 指定索引
# res = listvar.pop(33) 删除不存在的报错
remove()
'''
功能：通过给予的值来删除,如果多个相同元素,默认删除第一个
格式：列表.remove(值)
返回值：无
(注意：如果有索引的情况推荐使用pop,效率高于remove)
'''
listvar = [1,2,3,4,5]
listvar.remove(4)
print(listvar) # [1,2,3,5]
clera()
'''
功能：清空列表
格式：列表.clear()
返回值：空列表
'''
listvar = [1,2,3,4,5]
listvar.clear()
print(listvar) # []
index()
'''
功能：获取某个值在列表中的索引
格式：列表.index(值[,start][,end]) # [] 表达参数可选项
返回值：找到返回索引 (找不到报错)
'''
listvar = [1,2,3,4,54,4,90,4,78,78787,7878]
res = listvar.index(3) # 2
# res = listvar.index(99) # 如果索引不存在直接报错
res = listvar.index(4,4) # 5
res = listvar.index(4,6,9) # 指定索引的查找范围,高位取不到
print(res)
count()
'''
功能：计算某个元素出现的次数
格式：列表.count(值)
返回值：次数
'''
listvar = [1,2,3,4,54,4,90,4,78,78787,7878]
res= listvar.count(4)
print(res) # 3
sort()
'''
功能：列表排序(默认小到大排序)
格式：列表.sort(reverse=False)
返回值：None
注意：直接更改原列表
'''
listvar = [78,12,-3,99]
# 默认从小到大排序 (正序)
listvar.sort()
print(listvar)
# 从大到小排序 用reverse = True (倒叙)
listvar.sort(reverse=True)
print(listvar)
reverse()
'''
功能：列表反转操作
格式：列表.reverse()
返回值：None
注意：直接更改原列表
'''
listvar = [78,12,-3,99]
listvar.reverse()
print(listvar)
深浅拷贝
a = 10
b = a
a = 20
print(b) # 10
listvar = [1,2,3]
lst2 = listvar
listvar.append(6)
print(lst2) # [1, 2, 3, 6]
print(listvar is lst2) # True
# 浅拷贝
# 方法一
listvar = [1,2,3]
lst2 = listvar.copy()
listvar.append(6)
print(lst2) # [1, 2, 3]
# 方法二
import copy
listvar = [1,2,3]
lst = copy.copy(listvar)
listvar.append(6)
print(lst) # [1, 2, 3]
# 深拷贝
import copy
lst = [{'a':{'c':1,'d':3},'b':[5,6,7,8]},4,5]
# 浅拷贝只能拷贝列表的一级
# 如果想要拷贝所有层级，需要使用深拷贝
lst2 = copy.deepcopy(lst)
lst[0]['b'].append(9)
print(lst) # [{'a': {'c': 1, 'd': 3}, 'b': [5, 6, 7, 8, 9]}, 4, 5]
print(lst2) # [{'a': {'c': 1, 'd': 3}, 'b': [5, 6, 7, 8]}, 4, 5]
字典的相关函数
增
dictvar = {'a':1,'b':2}
dictvar['c'] = 3
print(dictvar) # {'a': 1, 'b': 2, 'c': 3}
# fromkeys() 使用一组键和默认值创建字典（不常用，赋初始值）
listvar = [1,2,3]
res = {}.fromkeys(listvar,None)
print(res) # {1: None, 2: None, 3: None}
res = {}.fromkeys(listvar,[1,2])
print(res) # {1: [1, 2], 2: [1, 2], 3: [1, 2]}
# 1,2,3中的值 是三个不同变量指向同一个空间的地址值
删
# pop() 通过键去删除键值对（若没有该键可设置默认值，预防报错）
dictvar = {"top":"程咬金","middle":"甄姬","bottom":"鲁班七号"}
res = dictvar.pop("top")
print(res) # 程咬金
print(dictvar) # {'middle': '甄姬', 'bottom': '鲁班七号'}
# pop()可以在第二参数上指定默认值，预防不存在该键时报错
res = dictvar.pop('1111111','该键有吗')
print(res) # 该键有吗
# popiten() 删除最后一个键值对
dictvar = {"top":"程咬金","middle":"甄姬","bottom":"鲁班七号"}
res= dictvar.popitem()
print(res) # ('bottom', '鲁班七号')
print(dictvar) # {'top': '程咬金', 'middle': '甄姬'}
# clear() 清空字典
dictvar = {"top":"程咬金","middle":"甄姬","bottom":"鲁班七号"}
dictvar.clear()
print(dictvar) # {}
改
# update() 批量更新（有该键就更新，没有就创建并添加）
dictvar = {"top":"程咬金","middle":"甄姬","bottom":"鲁班七号"}
# 写法一 在括号里面写字典数据（一个字典即可）
dictvar.update({'top':111,'jungle':222})
print(dictvar) # {'top': 111, 'middle': '甄姬', 'bottom': '鲁班七号', 'jungle': 222}
# 写法二 在括号里写关键字参数
dictvar.update(a=1,b=2,top=3)
print(dictvar) # {'top': 3, 'middle': '甄姬', 'bottom': '鲁班七号', 'a': 1, 'b': 2}
查
# get() 通过键获取值（若没有该键返回None,也可以设置默认值，预防报错）
dictvar = {"top":"程咬金","middle":"甄姬","bottom":"鲁班七号"}
res = dictvar.get("top123") # None
res = dictvar.get("top123","对不起") # 对不起
res = dictvar['top'] # 程咬金
# keys() 将字典的键组成新的可迭代对象
dictvar = {"top":"程咬金","middle":"甄姬","bottom":"鲁班七号"}
res = dictvar.keys()
print(res)
for i in dictvar.keys():
print(i)
for i in dictvar:
print(i)
# values() 将字典中的值组成新的可迭代对象
dictvar = {"top":"程咬金","middle":"甄姬","bottom":"鲁班七号"}
res = dictvar.values()
print(res)
for i in res:
print(i)
# items() 将字典的键值对凑成一个个元组，组成新的可迭代对象
res = dictvar.items()
print(res)
for i in res:
print(i)
'''
('top', '程咬金')
('middle', '甄姬')
('bottom', '鲁班七号')
'''
for a,b in res:
print(a,b)
集合
交差并补
set1 = {"周星驰","周杰伦","周润发","王文"}
set2 = {"王健林","王思聪","王宝强","王文"}
# 交集 intersection() &
res = set1.intersection(set2)
print(res) # {'王文'}
res = set1 & set2
print(res) # {'王文'}
# 差集 difference() -
res = set1.difference(set2)
print(res) # {'周杰伦', '周星驰', '周润发'}
res = set2.difference(set1)
print(res) # {'王健林', '王思聪', '王宝强'}
res = set1 - set2
print(res) # {'周杰伦', '周星驰', '周润发'}
# 并集 union() |
res = set1.union(set2)
print(res) # {'周润发', '王健林', '周星驰', '王宝强', '王文', '王思聪', '周杰伦'}
res = set1 | set2
print(res) # {'周润发', '王健林', '周星驰', '王宝强', '王文', '王思聪', '周杰伦'}
# 对称差集 symmetric_difference()
# 补集情况涵盖在其中
res = set1.symmetric_difference(set2)
print(res) # {'王宝强', '王健林', '周星驰', '王思聪', '周润发', '周杰伦'}
res = set1 ^ ser2
print(res) # {'王宝强', '王健林', '周星驰', '王思聪', '周润发', '周杰伦'}
# issubset() 判断是否是子集(真子集:子集元素一定少于父集,完全被包含在其中)
set_father = {"周星驰","周杰伦","周润发","王文"}
set_son = {"周杰伦","周润发"}
res = set_son.issubset(set_father)
print(res) # True
res = set_son < set_father
print(res) # True
# 这个情况下,两个集合完全一样,分不清子父关系,不是真子集
set_father = {"周星驰","周杰伦","周润发","王文"}
set_son = {"周星驰","周杰伦","周润发","王文"}
res = set_son <= set_father
print(res) # True
# issuperset() 判断是否是父集
set_father = {"周星驰","周杰伦","周润发","王文"}
set_son = {"周星驰","周杰伦"}
res = set_father.issuperset(set_son)
print(res) # True
res = set_father > set_son
print(res) # True
set_father = {"周星驰","周杰伦","周润发","王文"}
set_son = {"周星驰","周杰伦","周润发","王文"}
res = set_father >= set_son
print(res) # True
#isdisjoint() 检测两集合是否不相交 不相交 True 相交False
set_father = {"周星驰","周杰伦","周润发","王文"}
set_son = {"周星驰","周杰伦"}
res = set_father.isdisjoint(set_son)
print(res) # 是相交的 所以是false
集合的相关函数
# 增
#add() 向集合中添加数据
setvar = {"刘浩杰","徐信信","何伟福","林志远"}
setvar.add("胡斌")
print(setvar)
#update() 迭代着增加
setvar = {"刘浩杰","徐信信","何伟福","林志远"}
lst = ['胡家豪',"胡启超"]
setvar.update(lst) #把列表当中的元素一个一个拿出来放进集合中,需要时可迭代性数据
setvar = {"刘浩杰","徐信信","何伟福","林志远"}
strvar = "abcd"
setvar.update(strvar)
print(setvar)
# 删
#clear() 清空集合
setvar = {"刘浩杰","徐信信","何伟福","林志远"}
setvar.clear()
print(setvar)
#pop() 随机删除集合中的一个数据
setvar = {"刘浩杰","徐信信","何伟福","林志远"}
res = setvar.pop()
print(res)
print(setvar)
#remove() 删除集合中指定的值(不存在则报错)
setvar = {"刘浩杰","徐信信","何伟福","林志远"}
setvar.remove("徐信信")
print(setvar)
# setvar.remove("徐信信1")
#discard() 删除集合中指定的值(不存在的不删除 推荐使用)
setvar = {"刘浩杰","徐信信","何伟福","林志远"}
setvar.discard("何伟福121211212") # 如果这个值不存在,就不删除,也不报错
print(setvar)
# ### 冰冻集合
'''
#frozenset 可强转容器类型数据变为冰冻集合
冰冻集合一旦创建,不能在进行任何修改,只能做交叉并补操作
'''
# 定义一个空冰冻集合
fz = frozenset()
print(fz,type(fz))
fz1 = frozenset([1,"2",3,4])
fz2 = frozenset("7892")
print(fz1,fz2)
# 并冻集合只能做交叉并补
res = fz1 & fz2
print(res)
# fz1.add(4) error 没有增加或删除操作
文件操作
文件的读写操作
'''
fp = open('打开的文件',mode='模式选择',encoding='编码集')
open 函数 返回一个文件io对象（别名：文件句柄）
i => input 输入 o => output 输出
'''
# （1）写入文件内容（把大象放到冰箱三部曲）
# 打开文件(打开冰箱门)
fp = open('1.txt',mode='w',encoding='utf-8')
# 写入内容（放入大象）
fp.write('我就是那个大象')
# 关闭文件（关闭冰箱门）
fp.close()
# （2）读取文件内容
fp = open('1.txt',mode='r',encoding='utf-8')
res = fp.read()
fp.close()
print(res)
# b bytes模式（二进制的字节流）
'''
一堆字符放在一起 是字符串
一堆字节放在一起 是字节流
字节流用来传输数据和保存数据
'''
# 在ASCII编码字符前加上b，代表二进制字节流，其他所有字符都不能这样加
strvar = b'123'
print(strvar,type(strvar)) # b'123' <class 'bytes'>
# 使用encode和decode来把中文转化成二进制字节流
# encode把中文变成字节流（编码）
strvar = '你好python'
res = strvar.encode('utf-8')
print(res)
# decode 把字节流变成中文（解码）
strvar = res.decode('utf-8')
print(strvar)
# 复制图片
# 实际上就是把图片中的二进制字节流拷贝出来，放到另外一个文件当中
'''二进制字节流模式，不要指定编码集utf-8'''
# 读取文件里的内容
fp = open('1.png','rb')
res = fp.read()
fp.close()
# 写入另外一个文件
fp = open('2.png','wb')
fp.write(res)
fp.close
文件的扩展模式 +
在urf-8编码格式下 默认一个中文三个字节 一个英文或符号占用一个字节
read() 功能: 读取字符的个数（里面的参数代表字符个数）
seek() 功能: 调整指针的位置（里面的参数代表字节个数）
tell() 功能: 当前光标左侧所有的字节数（返回字节数）
r模式不能够自动创建文件，w和a都可以自动创建文件
r+模式：
# (1) r+ 可读可写（先读后写）
fp = open('2.txt',mode='r+',encoding='utf-8')
res = fp.read() # 读之前光标在0 读之后在末尾 所以写的时候等于追加
print(res)
fp.write('你好呀')
# 读取所有字符串
fp.seek(0)
res = fp.read()
fp.close()
print(res)
# （2）r+ 可读可写（先写后读）
fp = open('3.txt',mode='r+',encoding='utf-8')
fp.seek(0,2) # 写之前把光标放到文件末尾，不然把前面的内容覆盖
fp.write('闫帅')
fp.seek(0) # 写完之后把光标放到文件开头，不然读不到内容
res = fp.read()
fp.close()
print(res)
w+模式：
# w+ 可读可写 默认光标在文件的开头
fp = open('4.txt',mode='w+',encoding='utf-8')
fp.write('今天要学习完函数')
# 可读
fp.seek(0)
res = fp.read()
print(res)
fp.close()
a+模式：
# a+ append 可读可写 (默认光标在文件的结尾) (在写入的时候,只能在末尾强制追加)
fp = open("5.txt",mode="a+",encoding="utf-8")
fp.write("今天晚上要早走")
fp.seek(0)
res = fp.read()
print(res)
fp.close()
with语法
# 可以使用with 语法 简化操作 可以省去fp.close() 这句代码,实现自动关闭
# with + open(文件操作) as 为open的返回值起别名 fp 就是名称
# 相当于 fp = open() 一样的
with open("6.txt",mode="a+",encoding="utf-8") as fp:
fp.write("ceshidaima")
fp.seek(0) # fp.seek(0,2) 移动到文件的末尾
res= fp.read()
print(res)
# fp.close 这句话 with语法自动帮助我们完成
# 简化文件复制操作 open 之间 可以用逗号,隔开 为了简化操作
with open("集合.png",mode="rb") as fp1,open("集合3.png",mode="wb") as fp2:
res = fp1.read()
strvar = fp2.write(res)
文件操作的相关函数
（1）flush 刷新缓冲区
'''
当文件关闭的时候自动刷新缓冲区
当整个程序运行结束的时候自动刷新缓冲区
当缓冲区满了 会自动刷新缓冲区
手动刷新缓冲区
'''
fp = open("7.txt",mode="w+",encoding="utf-8")
fp.write("我在测试close操作")
# 立刻把缓冲区里面的内容刷入文件当中,缓冲区只是临时存储数据用的.不会一直存数据
fp.flush()
# while True:
# pass
fp.close()
(2) readline() 读取一行内容
'''
readline(字符个数) 单位读的时字符的个数
如果当前字符个数 > 实际个数 那就只读当前行
如果当前字符个数 < 实际个数 那就按照给与的当前个数读取
'''
# 读出所有行数 每一行都读
fp = open("0414_8.txt",mode = "r+",encoding="utf-8")
res = fp.readline(3)
# res = fp.readline()
# 判断res是不是为空,如果不是空,则进去打印该字符串
while res:
print(res)
# 在继续向下读取一行
res = fp.readline() # 读到最后是一个'' bool('') => False
# 文件对象具有可迭代性
# 遍历fp对象 和 readline一行一行读取的操作是一样的.
for i in fp:
print(i)
(3) readlines() 将文件中的内容按照换行读取到列表当中
listvar = []
with open("0414_8.txt",mode = "r+",encoding="utf-8") as fp:
res = fp.readlines()
# 过滤数据
for i in res:
# 过滤两边的空白符
res = i.strip()
# 把过滤好的数据直接插入到列表当中
listvar.append(res)
print(listvar)
(4) writelines() 将内容是字符串的可迭代性数据写入文件中 参数:内容为字符串类型的可迭代数据
with open("0414_9.txt",mode="w+",encoding="utf-8") as fp:
# strvar = "123456"
# strvar = ["aaa",'bbb','ccc']
# res = str([1,2,3,4,5])
fp.writelines(res)
(5) truncate() 把要截取的字符串提取出来,然后清空内容将提取的字符串重新写入文件中 (字节)
with open("0414_9.txt",mode="r+",encoding="utf-8") as fp:
fp.truncate(5)
(6) readable() 判断文件对象是否可读 writable () 判断文件对象是否可写
fp = open("0414_9.txt",mode="w",encoding="utf-8")
res1 = fp.readable()
res2 = fp.writable()
print(res1,res2)
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
