Learn day3 深浅拷贝/格式化/字符串/列表/字典/集合/文件操作

1. pass break continue

 # ### pass  break continue
# (1) pass 过
"""如果代码块当中,什么也不写,用pass来进行站位"""
def func():
    pass

if 5 == 5:
    pass

# while 5>3:
    # pass

# (2) break 终止当前循环 (只能在循环当中使用)
# 打印1~10 如果遇到5就终止循环
i = 1
while i<=10:
    print(i)
    if i == 5:
        break
    i+=1

# error
"""
if 5==5:
    break
"""
i = 1
while i<=3:
    j = 1
    while j<=3:
        if j == 2:
            print(i,j)
            break
        j+=1

# (3) continue 跳过当前循环,从下一次循环开始 (只能在循环当中使用)
# 打印1~10,不包含5
"""
当i等于5的时候,continue跳过当前循环,后面的代码通通不执行
直接回到循环判断中,因为i没有自增,所以条件5<=10永远为真
发生死循环,为了避免这个情况,所以我们手动加1,在执行continue;
"""
i = 1
while i<=10:

    if i == 5:
        # 手动自增,预防死循环;
        i+=1
        continue
    print(i)
    i+=1

# 打印1~100 所有不包含4的数字.

# 方法一
i = 1
while i<=100:
    # 先判断
    if i % 10 == 4 or i // 10 == 4:
        i+=1
        continue
    # 后打印
    print(i)    

    i+=1

# 方法二 in
print("<======>")
i = 1
while i<=100:
    num = str(i)
    if "4" in num:
        i+=1
        continue

    print(i)
    i+=1

for i in range(1,101):
    num = str(i)
    if "4" in num:
        continue
    print(i)

2.format字符串格式化传参

"""{} 是format语法中的占位符"""
# (1)顺序传参
strvar = "{}向{}开了一枪,饮弹而亡"
strvar = strvar.format("银燕","王铁男")
print(strvar)

# (2)索引传参
strvar = "{1}给{0}一个大大的拥抱"
res = strvar.format("毕阳生","刘得元")
print(res)

# (3)关键字传参
strvar = "{shuaile}给{wubo}一个飞吻"
res = strvar.format(wubo="吴波",shuaile="帅乐")
print(res)

# (4)容器类型数据(列表或元组)传参
# (1)
strvar = "{0[1]}向{1[2]}抛了一个媚眼,神魂颠倒,鼻血直冒三万多尺"
res = strvar.format(["舒则会","郭一萌","刘璐"],("李祥海","孙兆强","无要诀"))
print(res)

# (2) format 当中如果是获取字典对应的值,不要加上引号
strvar = "{group2[qgqc]}向{group1[2]}抛了一个媚眼,神魂颠倒,鼻血直冒三万多尺"
res = strvar.format(group1=["邓良辉","刘志华","王文贤"],group2={"fhcm":"舒则会","byxh":"郭一萌","qgqc":"罗淞峰"})
print(res)

3. format字符串填充

# ### format 字符串填充
# (5)format的填充符号的使用( ^ > < )
"""
^ 原字符串居中
> 原字符串居右
< 原字符串居左

语法:
{who:*>10}
*  要填充的字符
>  原字符串居右
10 原字符个数+要填充的个数 = 长度10
"""
strvar = "{who:*^10}在长春长生公司{something:!<10},感觉{feel:>>8}"
res = strvar.format(who="李祖庆",something="扎疫苗",feel="爽歪歪")
print(res)

# (6)进制转换等特殊符号的使用( :d :f :s :, )
"""
:d 整型占位符
:f 浮点型占位符
:s 字符串占位符
:, 金钱占位符
"""

#:d
strvar = "王照买了{:d}个棒棒糖"
res = strvar.format(3)
print(res)

# :2d 占用2位,默认原字符居右
strvar = "王照买了{:<2d}个棒棒糖"
res = strvar.format(3)
print(res)

# :^3d 占用3位,原字符居中
strvar = "王照买了{:^3d}个棒棒糖"
res = strvar.format(3)
print(res)

# :f 浮点型占位符
strvar = "买一斤西红柿的价格是{:f}"
res = strvar.format(3.6)
print(res)
# :.2f
strvar = "买一斤西红柿的价格是{:.2f}"
res = strvar.format(3.6)
print(res)

# :s 字符串占位符 format 不能默认强转,只能是填充什么样的格式,就写什么样的数据
strvar = "{:s}"
# res = strvar.format("你好,大妹子") ok
# res = strvar.format(3.567)         no
print(res)

# 如果是%号用法,默认会进行强制类型转换,强转,但是format格式化时不会执行;
strvar = "%s" % (3.14334)
print(strvar)

# :, 金钱占位符
strvar= "{:,}"
res = strvar.format(123456789)
print(res)

# 综合案例
strvar = "黄花买了{:d}个布加迪威龙,价格{:.1f},心情{:s}"
res = strvar.format(3,9.9,"好极了")
print(res)

4.字符串操作

# ### 字符串的函数
"""  字符串.函数()  """
# *capitalize 字符串首字母大写
strvar = "i love you baby"
res = strvar.capitalize()
print(res)

# *title 每个单词的首字母大写 (非字母隔开的单词)
strvar = "i hate you bigbrother"
# strvar = "i hate you87342426734bigbrother"
res = strvar.title()
print(res)

# *upper 将所有字母变成大写
strvar = "you love me"
res = strvar.upper()
print(res)

# *lower 将所有字母变成小写
strvar = "I MISS YOU"
res = strvar.lower()
print(res)

# *swapcase 大小写互换
strvar = "to be OR not to be"
res = strvar.swapcase()
print(res)

# *count 统计字符串中某个元素的数量
res = "是生是死,的确是一个问题".count("是")
print(res)

# *find 查找某个字符串第一次出现的索引位置
"""find("字符串",[开始索引,结束索引]),结束索引的最大值取不到"""
strvar = "Oh father this is my favorite girls"
res = strvar.find("father")
print(res)
res = strvar.find("s",3)
print(res) # 13
# 14~17的这个索引区间找s这个字符的索引号,最大值是取不到的;
res = strvar.find("s",14,18)
print(res)
# 如果找不到该字符,直接返回-1,表达没有
res = strvar.find("你")
print(res)

# *index 与 find 功能相同 find找不到返回-1,index找不到数据直接报错
"""推荐使用find ,因为index会报错,终止程序;"""
# res = strvar.index("你")

# *startswith 判断是否以某个字符或字符串为开头
"""endswith,startswith(字符串,[开始索引,结束索引]) 结束索引最大值取不到"""

strvar = "Oh father this is my favorite girls"
res = strvar.startswith("Oh")
print(res)
res = strvar.startswith("father",3)
res = strvar.startswith("father",4)
print(res)

# *endswith   判断是否以某个字符或字符串结尾
res = strvar.endswith("girls")
print(res)
res = strvar.endswith("my",18,20)
res = strvar.endswith("y",18,20)
print(res)

# *split 按某字符将字符串分割成列表(默认字符是空格)
strvar = "you can you up no can no bb"
res = strvar.split()
print(res)
strvar = "you,can,you,up,no,can,no,bb"
res = strvar.split(",")
print(res)
# 可以选择分隔的次数
res = strvar.split(",",4)
print(res)

# rsplit 从右向左分隔
res = strvar.rsplit(",")
print(res)
# 一样可以选择分隔的次数
res = strvar.rsplit(",",4)
print(res)

# *join  按某字符将列表拼接成字符串(容器类型都可)
lst = ['you', 'can', 'you', 'up', 'no', 'can', 'no', 'bb']
res = "-".join(lst)
print(res)

# *replace 替换字符串(可选择替换的次数) 默认替换所有
strvar = "可爱的小狼狗喜欢吃肉,有没有,有没有,还有没有"
# replace(替换谁,替换成什么,[替换几次])
res = strvar.replace("有没有","真没有")
print(res)
res = strvar.replace("有没有","真没有",2)
print(res)

# *isalnum 判断字符串是否是由数字、字母、汉字组成
strvar= "2342sdfsd你好&*&*"
strvar= "2342"
res = strvar.isalnum()
print(res)

# *isdigit 检测字符串数是数字组成 接受二进制字节流
"""
# 二进制字节流 : 传输数据,存储数据
字符串 => 一个一个字符组成
字节流 => 一个一个字节组成
1byte = 8bit
1B = 8b

语法格式:b"字符串"

# 注意点:
b开头的二进制字节流,里面的字符编码只能是ascii编码;
encode
decode
用来转换中文变成二进制的字节流;中文前面加b是错误的;

strvar = b"1234454" # 二进制字节流
# strvar = b"你好上" error
"""
strvar = "123456"
res = strvar.isdigit()
print(res)
strvar = b"89898"
res = strvar.isdigit()
print(res)

# *isdecimal 检测字符串是否以数字组成  必须是纯数字
strvar = "123456"
# strvar = b"89898" error 不能识别二进制的字节流
res = strvar.isdecimal()
print(res)

# *len 计算容器类型长度
strvar = "阳光洒在手指间"
res = len(strvar)
print(res)

# *center 填充字符串,原字符居中 (默认填充空格)
strvar = "李祖清"
# 10 是一共的长度 原字符串长度+ 填充字符 = 10
# center(长度,[要填充的字符,默认不写填充空格])
res = strvar.center(10)
res = strvar.center(10,"%")
print(res)

# *strip  默认去掉首尾两边的空白符
"""网站注册的时,在存在数据库之前,先处理两边的空白符"""
strvar = "                                       刘德华     "
res = strvar.strip()
print(res)
strvar = "@王战"
res = strvar.strip("@")
print(res)

5. 列表操作

# ### 列表相关操作
# (1)列表的拼接   (同元组) +
lst1 = [1,2,3]
lst2 = [4,5,6,1]
lst = lst1 + lst2
print(lst)

# (2)列表的重复   (同元组) *
lst = [2,3]
res = lst * 3
print(res)

# (3)列表的切片   (同元组)
# 语法 => 列表[::]  完整格式：[开始索引:结束索引:间隔值]
    # (1)[开始索引:]  从开始索引截取到列表的最后
    # (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
    # (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
    # (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
    # (5)[:]或[::]  截取所有列表

lst = ["王振华","李祖清","文昭才","陈凤杰","温红杰","刘璐","等两会","刘志华"]
# (1)[开始索引:]  从开始索引截取到列表的最后
res = lst[3:]
print(res)

# (2)[:结束索引]  从开头截取到结束索引之前(结束索引-1)
res = lst[:4]
print(res)

# (3)[开始索引:结束索引]  从开始索引截取到结束索引之前(结束索引-1)
res = lst[5:7]
print(res)

# (4)[开始索引:结束索引:间隔值]  从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
res = lst[::3] # 正向截取
#0 3 6
print(res)

res = lst[7:0:-2] # 逆向截取
#7 5 3 1
print(res)

# (5)[:]或[::]  截取所有列表
res = lst[:]
res = lst[::]
print(res)    

# (4)列表的获取   (同元组)
#       0        1      2        3       4  正向索引
lst = ["宋江","吴用","卢俊义","林冲","杜十娘"]
#       -5       -4    -3      -2       -1  逆向索引
res = lst[4]
res = lst[-1]
print(res)

# (5)列表的修改   ( 可切片 )
lst[0] = "李祖清"
print(lst)

# 1.利用切片进行数据的修改
"""
可迭代数据:容器类型数据,range对象,迭代器
"""
# 先把1:4所对应的截取数据去除,然后在把可迭代数据中的元素,依次的拿出来进行对应位置赋值
"""无要求:截取的数据个数和实际放入的数据个数没有要求"""
lst[1:4] = ["石阡","鲁智深","武松","武大郎"]
print(lst)

# 2.利用切片+步长的方式进行数据的修改
"""有要求:切几个数据,就放上几个数据,元素个数要匹配"""
print(lst[::2])
# 0 2 4
lst[::2] = (1,2,3)
print(lst)

# (6)列表的删除   ( 可切片 ) del关键字删除
lst = ["宋江","吴用","卢俊义","林冲","杜十娘"]
del lst[1]
print(lst)
# 可以利用切片来删除
lst = ["宋江","吴用","卢俊义","林冲","杜十娘"]
del lst[1:3]
print(lst)
# 注意点
lst = ["宋江","吴用","卢俊义","林冲","杜十娘"]
# 把要删除的数据直接写在del 关键字的后面,如果删除res的话,是删除res这个变量,跟列表没有关系.
res = lst[1:3]
del res
print(lst)

# 元组相关操作
"""
元组针对于第一级所有的元素是修改不了的
但是如果含有二级容器,并且该容器可以修改,那么元组里面的二级或者多级可以修改
"""
tuplevar = (1,4,4,5,6,[434,645,43,(234,)])
res = tuplevar[-1]
print(res)
res[-2] = 88
print(tuplevar) #(1, 4, 4, 5, 6, [434, 645, 88, (234,)])

# 集合的值或者字典的键必须是可哈希数据=>不可变得数据类型(int bool float complex str tuple)
# setvar = {(1,2,3,4,5,6,[7,8,9])} # error unhashable type: 'list'

6.列表的相关函数\元组

# ### 列表的相关函数
listvar = [23,45,67]
# 增
# 1.append 向列表的末尾添加新的元素
res = listvar.append(16)
print(res) # 它的返回值没有任何意义
print(listvar)

# 2.insert 在指定索引之前插入元素
listvar = ["邓良辉","李祖清"]
listvar.insert(1,"刘志华")
print(listvar)

# 3.extend 迭代追加所有元素
listvar = ["邓良辉","李祖清"]
# 把元组当中的元素一个一个的插入到列表当中
listvar.extend( (1,2,3,4) )
print(listvar)

# 删
listvar = ["邓良辉","李祖清","舒则会","郭一萌","黄花"]
# 1. pop 通过指定索引删除元素,若没有索引移除最后那个 (推荐使用)
listvar.pop()
print(listvar)
listvar.pop(0)
print(listvar)

# 2.remove  通过给予的值来删除,如果多个相同元素,默认删除第一个
listvar = ["邓良辉","李祖清","舒则会","郭一萌","舒则会","黄花"]
listvar.remove("舒则会")
print(listvar)

# 3.clear 请空列表
listvar.clear()
print(listvar)
# 改  查
# 详见5.py

# 其他相关函数
listvar = ["邓良辉","李祖清","舒则会","郭一萌","舒则会","黄花","郭一萌","郭一萌"]
# 1.index 获取某个值在列表中的索引
"""index(要搜索的值,[开始索引,结束索引])"""
res = listvar.index("郭一萌")
print(res)
res = listvar.index("郭一萌",4)
print(res)
res = listvar.index("郭一萌",6,7)
print(res)

# count() 计算某个元素出现的次数
res = listvar.count("郭一萌")
print(res)

# sort() 列表排序(默认小到大排序)
"""如果是字母,按照ascii编码进行排序"""
listvar = ["james","jand","qz","davis","smallkl"]
listvar.sort()
print(listvar)

# sort(reverse=True) (从大到小排序)
listvar = [-90,67,11,1000]
listvar.sort()
listvar.sort(reverse=True)
print(listvar)

# reverse 列表反转操作 相当于水平翻转
listvar = [1,88,-90,"a"]
listvar.reverse()
print(listvar)

"""
tuple 里面只有index和count两个函数可以用.剩下的基本操作和列表一样
"""

7.深浅拷贝

# ### 深拷贝 与 浅拷贝
"""
a = 7
b = a
a = 9
print(b)

# 列表赋值出现的问题:两个不同的变量指向同一个列表
lst1 = [1,2,3]
lst2 = lst1
lst1.append(4)
print(lst2)
"""
# 浅拷贝 copy [两个列表之间彼此独立,拷贝一个新的副本]
# 方法1
lst1 = [1,2,3]
lst2 = lst1.copy()

lst1.append(4)
print(lst1)
print(lst2)

# 方法2
'''import 引入 copy模块下的 copy方法 '''
import copy
lst1 = [1,2,3]
lst2 = copy.copy(lst1)
lst1.append(4)
print(lst1,lst2)

# 深拷贝
"""
浅拷贝只是单独复制一级列表里面所有元素
深拷贝可以复制所有级别的列表元素,都单独拷贝一份,
都形成独立的副本,彼此不受干扰
"""
# 出现的问题:
lst1 = [1,2,3,[4,5,6]]
lst2 = lst1.copy()
lst1[-1].append(7)
lst1.insert(2,666)
print(lst1)
print(lst2)

lst1 = [1,2,3,[4,5,6]]
lst2 = copy.deepcopy(lst1)
lst1[-1].append(999)
print(lst1)
print(lst2)

"""
看需求而定
浅拷贝的执行时间,要比深拷贝执行时间要快
而深拷贝是所有级别的列表都单独拷贝出来,形成独立副本
而浅拷贝仅仅只是拷贝一级的所有元素,二级的不考虑.
"""

container = [1,2,3,{"a":[4,5,6]}]
container2 = copy.deepcopy(container)
container[-1]["a"].append(888)
print(container)
print(container2)

8.字典相关操作

# ### 字典相关函数
# 1.增
dictvar = {}
dictvar["fhzm"] = "舒则会"
dictvar["byxh"] = "郭一萌"
dictvar["qgqc"] = "罗淞峰"
dictvar["cyly"] = "银燕"
dictvar["ttyl"] = "刘路"
print(dictvar)

# fromkeys()  使用一组键和默认值创建字典 (返回新字典)
listvar = ["a","b","c"]
dictvar = {}.fromkeys(listvar,None)
print(dictvar)

# fromkeys 不推荐使用,三个键所指向的是同一个列表;
dictvar = {}.fromkeys(listvar,[1,2,3])
print(dictvar)
dictvar["a"].append(4)
print(dictvar)

# 2.删
dictvar = {'fhzm': '舒则会', 'byxh': '郭一萌', 'qgqc': '罗淞峰', 'cyly': '银燕', 'ttyl': '刘路'}
# 2.1 pop()       通过键去删除键值对 (若没有该键可设置默认值,预防报错)
res = dictvar.pop("cyly")
print(res)
print(dictvar)

# 当删除一个不存在的键时,直接报错,
# res = dictvar.pop("xboyww") error
# 为了预防报错,可以设置默认值
res = dictvar.pop("xboyww","设置默认值,该神秘男子不存在")
print(res)

# 2.2 popitem()   删除最后一个键值对
dictvar = {'fhzm': '舒则会', 'byxh': '郭一萌', 'qgqc': '罗淞峰', 'cyly': '银燕', 'ttyl': '刘路'}
res = dictvar.popitem()
print(res)
print(dictvar)

# 2.3 clear()  清空字典
dictvar.clear()
print(dictvar)

# 3.改
#update() 批量更新(有该键就更新,没该键就添加)
dictvar = {"鼓上骚":"石阡","母夜叉":"杜十娘","浪里白条":"张顺","花和尚":"录制山","入云龙":"公孙上","黑旋风":"李奎"}
# 更新方式1 (推荐)
dictvar.update(  {"神秘男孩":"王文","闭月羞花":"郭一萌","倾国倾城":"罗送风","入云龙":"公孙胜"}   )
print(dictvar)
# 更新方式1
dictvar.update( zhiduoxing="吴用",jishiyu = "宋江" )
print(dictvar)

# 4.查
#get()    通过键获取值(若没有该键可设置默认值,预防报错) 最大的好处在没有该键的时候不报错
dictvar = {"鼓上骚":"石阡","母夜叉":"杜十娘","浪里白条":"张顺","花和尚":"录制山","入云龙":"公孙上","黑旋风":"李奎"}
res = dictvar.get("母夜叉123")
print(res) # None
# 设置默认值
res = dictvar.get("母夜叉123","该母老虎没有")
print(res)

# 其他
#keys()   将字典的键组成新的可迭代对象
dictvar = {"鼓上骚":"石阡","母夜叉":"杜十娘","浪里白条":"张顺","花和尚":"录制山","入云龙":"公孙上","黑旋风":"李奎"}
res1 = dictvar.keys()
print(res1)

#values() 将字典中的值组成新的可迭代对象
res2 = dictvar.values()
print(res2)

#items()  将字典的键值对凑成一个个元组,组成新的可迭代对象
res3 = dictvar.items()
print(res3)

for i in res3:
    print(i)

9.集合相关操作

# ### 集合相关操作
set1 = {"王文","刘德华","张学友","郭富城"}
set2 = {"王文","王宝强","李宇春","蔡徐坤"}
#intersection() 交集
res = set1.intersection(set2)
print(res)
# 简便写法 &
res = set1 & set2
print(res)

#difference()   差集
res = set1.difference(set2)
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 ^ set2
print(res)

#issubset()   判断是否是子集
set1 = {"舒则会","郭一萌","黄瓜","孙兆强"}
set2 = {"舒则会","郭一萌"}
set3 = {"舒则会","郭一萌","黄瓜","孙兆强"}
res = set2.issubset(set1)
print(res)
# 简便写法 <
res= set2 < set1 # 真集合
print(res)
res = set1 <= set3
print(res) #True

#issuperset() 判断是否是父集
set1 = {"舒则会","郭一萌","黄瓜","孙兆强"}
set2 = {"舒则会","郭一萌"}
res = set1.issuperset(set2)
print(res) # True

# 简便写法 >
res = set1 > set2
print(res) # True

#isdisjoint() 检测两集合是否不相交  不相交 True  相交False
set1 = {"舒则会","郭一萌","黄瓜","孙兆强"}
set2 = {"舒则会","郭一萌"}
res = set1.isdisjoint(set2)
print(res) #False 代表相交

# ### 集合相关的函数
# 1.增
#add()    向集合中添加数据
setvar = {"赖廷","银燕","毕养生"}
setvar.add("易烊千玺")
print(setvar)

#update() 迭代着增加
"""把可迭代性容器里面的数据一个一个的拿出来放到setvar当中"""
setvar.update([1,2,3,4,"a","b","c"])
print(setvar)

# 2.删
setvar = {"a","c","ddd"}

#pop()     随机删除集合中的一个数据
res = setvar.pop()
print(res)
print(setvar)

#remove()  删除集合中指定的值(不存在则报错)
# setvar.remove("aaaaa")
# print(setvar)

#discard() 删除集合中指定的值(不存在的不删除 推荐使用) (推荐)
setvar.discard("aaaaa")
print(setvar)

#clear()  清空集合
setvar.clear()
print(setvar)

# ### 冰冻集合
#frozenset 可强转容器类型数据变为冰冻集合
# 冰冻集合一旦创建,不能在进行任何修改,只能做交叉并补操作

# 定义一个空的冰冻集合
fz = frozenset()
print(fz)
# 强制转换为一个冰冻集合
listvar = [1,23,3,43,43]
fz = frozenset(listvar)
print(fz)

for i in fz:
    print(i)

# 只能做交叉并补
fz1 = frozenset(["李宇春","王宝强"])
fz2 = frozenset({"李宇春","王文","周杰伦"})
res = fz1 & fz2
print(res)

# 不能做增删操作 错误的
# fz1.add("郭富城") error 

10.文件操作

# ### 文件操作
"""
对象.属性
对象.方法() 来调用其中的内容;
fp = open(文件名,采用的模式,字符编码)
open返回的是一个文件io对象,别名(文件句柄)
i=>input  输入
o=>output 输出
"""

# (1)文件写入操作
# 1.打开文件
fp = open("ceshi0707.txt",mode="w",encoding="utf-8") # 1.把冰箱门打开
# 2.写入内容
fp.write("把大象扔进去") # 2.把大象放进去
# 3.关闭文件
fp.close() # 3.把冰箱门关上

# (2)文件读取操作
# 1.把冰箱门打开
fp = open("ceshi0707.txt",mode="r",encoding="utf-8")
# 2.把大象拿出来
res = fp.read()
# 3.把冰箱门关上
fp.close()

print(res)

# (3) encode 和 decode
# 将字符串和字节流(Bytes流)类型进行转换 (参数写成转化的字符编码格式)
    #encode() 编码  将字符串转化为字节流(Bytes流)
    #decode() 解码  将Bytes流转化为字符串
# \xe9\xbb\x84\xe8\x8a\xb1\xe7\x9c\x9f\xe5\xb8\x85
# encode 将字符串转化为字节流
strvar = "黄花真帅"
res = strvar.encode("utf-8")
print(res)
# decode 将Bytes流转化为字符串
strvar2 = b'\xe9\xbb\x84'
res2 = strvar2.decode("utf-8")
print(res2)
res3 = res.decode("utf-8")
print(res3)

# 程序员的表白方式
# b'\xe6\x88\x91\xe7\x88\xb1\xe4\xbd\xa0'
strvar = "我爱你王文"
print(strvar.encode("utf-8"))

# wb rb的模式写法
"""
如果模式当中含有b,不要指定encoding编码集.否则报错
"""
# 4.把内容变成二进制字节流存储在文件中
# (1) 打开文件
fp = open("0707_1.txt",mode="wb")
strvar = "王铁男真硬"
res = strvar.encode("utf-8")
# (2) 写入内容
fp.write(res)
# (3) 关闭文件
fp.close()

# 5.把二进制字节流从文件中读出来转成原来的格式decode
# (1) 打开文件
fp = open("0707_1.txt",mode="rb")
# (2) 读取内容
res = fp.read()
# (3) 关闭文件
fp.close()
print(res)

res = res.decode("utf-8")
print(res)

# 6.复制图片
"""
但凡是图片或者是音频或者是视频,本质上都是二进制字节流的文件
如果想要复制,先把内容通过二进制字节流模式读取出来,
然后在写入到另外一个文件当中.
"""

# 把文件内容读出来
fp = open("集合.png",mode="rb")
res = fp.read()
fp.close()

# 把文件内容写到另外一个文件中
fp = open("集合2.jpg",mode="wb")
fp.write(res)
fp.close()

11. 文件扩展模式

# ### 文件的扩展模式
"""在w r a 三个模式的后面套上一个+加号,使该模式又可读,又可写"""
# (utf-8编码格式下 默认一个中文三个字节 一个英文或符号 占用一个字节)
    #read()        功能: 读取字符的个数(里面的参数代表字符个数)
    #seek()        功能: 调整指针的位置(里面的参数代表字节个数)
        # seek(0)   移动到文件的开头
        # seek(0,2) 移动到文件的结尾
    #tell()        功能: 当前光标左侧所有的字节数(返回字节数)

# r+ 先读后写
# fp = open("0707_2.txt",mode="r+",encoding="utf-8")
# res = fp.read()
# print(res)
# fp.write("789")
# fp.close()

# r+ 先写后读
fp = open("0707_2.txt",mode="r+",encoding="utf-8")
# 把光标移动到最后,防止对原字符进行替换
fp.seek(0,2)
fp.write("abc")
# seek(0) 是把当前光标移动到开头,read默认以当前光标位置向右读取内容;
fp.seek(0)
res = fp.read()
print(res)
fp.close()

# w+ 可读可写
fp = open("0707_3.txt",mode="w+",encoding="utf-8")
fp.write("我可真迷人呀")
fp.seek(0)
res = fp.read()
fp.close()

print(res)

# a+ 可读可写 (当写入内容时,强制吧光标移动到最后.)
# (1)默认a模式可写
fp = open("0707_4.txt",mode="a",encoding="utf-8")
fp.write("123456")
# fp.read() error
fp.close()

# (2)a+模式可读可写
fp = open("0707_4.txt",mode="a+",encoding="utf-8")
fp.write("123456")

fp.seek(0)
res = fp.read()
fp.close()
print(res)

# (3) 追加内容时,光标是强制在最后的,如果是读取可以随意调整光标位置
fp = open("0707_4.txt",mode="a+",encoding="utf-8")
fp.seek(0)
fp.write("789")
fp.close()

# read seek tell 综合使用
# read后面加的参数值单位是字符个数,如果不写值,代表读取所有
# 例子1
fp = open("0707_5.txt",mode="r+",encoding="utf-8")
fp.seek(3)
res = fp.read(2)

print(res)
# 获取当前光标左侧所有的字节数的
res = fp.tell()
print(res)

fp.close()

# 例子2 含有中文的时候要小心,一个中文代表的是3个字节.在移动seek的时候,容易出现乱码
"""读中文字符如果不完整发生报错"""
"""
fp = open("0707_6.txt",mode="r+",encoding="utf-8")
fp.seek(5)
res = fp.read()
print(res)
"""
# print("我".encode()) #\xe6\x88\x91

# ### with 语法 可以自动实现关闭操作close()
# 把文件内容读出来
# fp = open("集合.png",mode="rb")
# res = fp.read()
# fp.close()

# 用with改写  as 就是起别名的意思  叫fp
with open("集合.png",mode="rb") as fp:
    res = fp.read()

# 把文件内容写到另外一个文件中
# fp = open("集合2.jpg",mode="wb")
# fp.write(res)
# fp.close()

# 用with改写 as 就是起别名的意思 叫fp
with open("集合2.jpg",mode="wb") as fp:
    fp.write(res)

# 简化操作
with open("集合.png",mode="rb") as fp1 , open("集合3.jpg",mode="wb") as fp2:
    res = fp1.read()
    fp2.write(res)

12.文件相关函数

# ### 文件相关函数

# 1.文件对象可以遍历 文件对象也是一个可迭代性数据
"""
fp = open("0707_7.txt",mode="r+",encoding="utf-8")
#readable()        功能: 判断文件对象是否可读
res = fp.readable()
print(res)
#writable()        功能: 判断文件对象是否可写
res = fp.writable()
print(res)

# 文件对象可以遍历 ,默认遍历一次,读取一行
for i in fp:
    print(i)
"""

# 2.readline
# (1)readline()     功能: 读取一行文件内容
"""
readline(字符个数)
如果参数字符个数大于当前行所有的字符个数,那么读取当前行
如果参数字符个数小于当前行所有的字符个数,那么读取实际字符数
"""
# 读出文件所有内容
with open("0707_7.txt",mode="r",encoding="utf-8") as fp:
    res = fp.readline(20)
    print(res)
    # res = fp.readline()
    # res = fp.readline()
    # print(res)
    # while res:
        # print(res)
        # res = fp.readline()

# (2)readlines()    功能：将文件中的内容按照换行读取到列表当中
lst_new = []
with open("0707_7.txt",mode="r",encoding="utf-8") as fp:
    lst = fp.readlines()
    print(lst)
    for i in lst:
        res = i.strip()
        lst_new.append(res)
print(lst_new)

#writelines()   功能：将内容是字符串的可迭代性数据写入文件中 参数:内容为字符串类型的可迭代数据
"""
1.括号里的参数是可迭代性数据
2.内容的类型是字符串
"""
with open("0707_8.txt",mode="w",encoding="utf-8") as fp:
    lst = ['我爱你\n', '美丽的哈姆雷特\n', '我喜欢你潇洒的面庞\n', '修长的手指头\n', '和 文雅的气质\n', '那忧郁的眼神\n', '让我神魂颠倒不能自拔\n']
    # lst = [1,2,3] error
    fp.writelines(lst)

#truncate()     功能: 把要截取的字符串提取出来,然后清空内容将提取的字符串重新写入文件中 (字节)

"""
总结:
    read(字符)
    seek(字节)
    readline(字符)
    truncate(字节)
"""