一，复习
\'\'\'
类型转换
1.数字类型：int() | bool() | float()
2.str与int： int(\'10\') | int(\'-10\') | int(\'0\') | float(\'-.5\') | float(\'3.14\') | str(数字)
3.重点 - str与list：
\'abc\' => [\'a\', \'b\', \'c\']: list(\'abc\') | \'\'.join([\'a\', \'b\', \'c\'])
\'abc|def|xyz\' => [\'abc\', \'def\', \'xyz\']: s.split(\'|\') | \'|\'.join(ls)
4.list、set、tuple：类型()
5.list与dict：
a=1&b=2&c=3 <=> [(\'a\', 1), (\'b\', 2), (\'c\', 3)] <=> {\'a\': 1, \'b\': 2, \'c\': 3}
dic = {}
for k, v in [(\'a\', 1), (\'b\', 2), (\'c\', 3)]:
dic[k] = v
ls = []
for k, v in {\'a\': 1, \'b\': 2, \'c\': 3}.items():
ls.appen((k, v))
6.可以通过字典构建任意数据的映射关系：
type_map = {
1: \'壹\',
\'壹\': 1,
\'owen\'：(1, 88888),
\'add\': add # add是功能(函数)
}
字符编码：
编码表：人能识别的符号与机器能识别的符号(01组成的二进制码)映射关系
py2：ASCII，常用ASCII表只有英文、数字、英文符号与与机器能识别的符号的对应关系
py3：utf-8，是unicode编码表的一种实现方式，采用变长存储数据，字母数字简单符号1个字节，中文3~6字节
utf-8: 变长，在英文数字较多时，更节省空间，用于传输，cpu与硬盘中采用的编码格式
utf-16: 定长，英文数字汉字都是采用2个字节，读存效率高，内存中采用的编码格式
gbk => utf-8: 转码
普通字符串 => 二进制字符串：编码，目的是用于传输数据 \'abc\'.encode(\'utf-8\')
二进制字符串 => 普通字符串：解码，目的是用于显示数据 b\'abc\'.decode(\'utf-8\')
例子：
# ascii与字符的相互转换
print(10)
print(0B1010) # 二进制 0b
print(0o12) · # 八进制 0o
print(0xa) # 十六进制 0x
# 将数字转化为字符 chr
print(0b01000001) #65
print(chr(0b01000001)) #A
print(chr(65)) #A
# 将字符转化为数字 ord
print(ord(\'A\')) #65
print(chr(9326))
print(ord(\'①\')) #9312
# -128 ~127: 一个字节占8个二进制位，首位为符号位
# -32768~32767
# 11111111 ~ 01111111 => -127 ~ 127 | 10000000(-128), 00000000 => -128 ~127
# 原码 补码
print(\'abc呵呵\'.encode(\'utf-8\')) #b\'abc\xe5\x91\xb5\xe5\x91\xb5\'
print(b\'abc\xe5\x91\xb5\xe5\x91\xb5\'.decode(\'utf-8\')) #abc呵呵
# 二进制流
print(126187 * 16 + 7) #字节大小计算
\'\'\'
二，三种字符串
# 普通字符串：u\'以字符作为输出单位\'
print(u\'abc\') # 用于显示 abc
# 二进制字符串：b\'\' 二进制字符串以字节作为输出单位
print(b\'abc\') # 用于传输 b\'abc\'
# 原义字符串：r\'以字符作为输出单位，所有在普通字符串中能被转义的符号在这都原样输出\' print(u\'a\tb\nc\') print(r\'a\tb\nc\') # 取消转义 print(r\'F:\python8期\课堂内容\day08\代码\1.三种字符串.py\')
三，文件操作的三步骤
\'\'\'
1.打开文件: 硬盘空间被操作系统持有，文件对象被应用程序持有
f = open(\'source.txt\', \'r\', encoding=\'utf-8\')
2.操作文件
data = f.read()
3.释放文件：释放操作系统对硬盘空间的持有
f.close()
\'\'\'
四，基础的读
f = open(\'source.txt\', \'r\', encoding=\'utf-8\')
f.read() # 将所有内容一次性读完
f.read(10) # 读取指定字符数
f.readline() # 一次读取一行(文件的换行标识就是结束本次读取的依据)
f.readlines() # 将所有内容读存，按换行标识作为读取一次的依据，存放为列表
f.close()
五，基础的写
wf = open(\'target.txt\', \'w\', encoding=\'utf-8\')
wf.write(\'123\n\') # 一次写一条，行必须用\n标识
wf.write(\'456\n\')
wf.flush() # 向操作系统发送一条将内存中写入的数据刷新到硬盘
wf.write(\'789\n\')
wf.writelines([\'abc\n\', \'def\n\', \'xyz\n\']) # 一次写多行，行必须用\n标识
wf.close() # 1.将内存中写入的数据刷新到硬盘 2.释放硬盘空间
六，with_open语法
# 优化整合了文件资源的打开与释放
# -- 在with的缩进内可以操作文件对象，一旦取消缩进，资源就被释放了
# part1
# as起别名，rf持有文件资源的变量
with open(\'target.txt\', \'r\', encoding=\'utf-8\') as rf:
# 文件操作的具体代码
# 缩进一旦取消缩进，资源就被释放了
# part2
with open(\'target.txt\', \'r\', encoding=\'utf-8\') as rf1, open(\'target1.txt\', \'r\', encoding=\'utf-8\') as rf2:
print(rf1.read())
print(rf2.read())
# print(rf1.read()) # 报错
# print(rf2.read()) # 报错
# part3
with open(\'target.txt\', \'r\', encoding=\'utf-8\') as rf1:
with open(\'target1.txt\', \'r\', encoding=\'utf-8\') as rf2:
print(rf1.read())
print(rf2.read())
# print(rf1.read()) # 可以操作
# print(rf2.read()) # 不可以操作
七，文件的操作模式
\'\'\'
主模式：r | w | a | x
-- 主模式只能选取一个，规定着主要的操作方式
从模式：t | b | +
-- 从模式也必须出现，但个数不一定是一个，为主模式额外添加功能
r: 读，文件必须有，没有则报错
w: 清空写，文件可有可无，有则情况写，没有创建写
a: 追加写，文件可有可无，有则追加写，没有创建写
x：创建写，文件必须无，文件有则报错
t：默认，按字符操作
b：按字节操作
+：可读可写
#按照字符形式：
# rt: 文件必须提前存在，不存在报错，文件操作采用字符形式 - 简写为 r
# wt: 文件可以存在，也可以不存在，存在则清空后写入，不存在新建后写入，文件操作采用字符形式 - 简写为 w
# at: 文件可以存在，也可以不存在，存在在之前内容的末尾追加写入，不存在新建后写入，文件操作采用字符形式 - 简写为 a
#按照字节形式：
# rb: 文件必须提前存在，不存在报错，文件操作采用字节形式
# wb: 文件可以存在，也可以不存在，存在则清空后写入，不存在新建后写入，文件操作采用字节形式
# ab: 文件可以存在，也可以不存在，存在在之前内容的末尾追加写入，不存在新建后写入，文件操作采用字节形式
# r+t：文件必须存在的可读可写，默认从头开始替换写，按字符操作
# w+t：文件存在清空不存在创建的可读可写，按字符操作
# a+t：文件存在追加不存在创建的可读可写，按字符操作
# r+b：文件必须存在的可读可写，默认从头开始替换写，按字节操作
# w+b：文件存在清空不存在创建的可读可写，按字节操作
# a+b：文件存在追加不存在创建的可读可写，按字节操作
\'\'\'
八，文件的操作编码问题
\'\'\'
t模式下：原文件采用什么编码，你就选取什么编码操作，如果不选取，默认跟操作系统保持一致
-- t模式下一定要指定编码
b模式下：硬盘的数据就是二进制，且能根据内容识别出编码，写入时的数据也是通过某种编码提前处理好的，所有在操作时，没有必要再去规定编码
\'\'\'
九，文件的复制
# 文本文件的复制：可以t也可以b
with open(\'target.txt\', \'r\', encoding=\'utf-8\') as rf:
with open(\'target2.txt\', \'w\', encoding=\'utf-8\') as wf:
for line in rf:
wf.write(line)
with open(\'target.txt\', \'rb\') as rf:
with open(\'target3.txt\', \'wb\') as wf:
for line in rf:
wf.write(line)
# 非文本文件只能采用b模式操作，不需要指定编码 - 因为根本不涉及编码解码过程
with open(\'001.mp4\', \'rb\') as rf:
with open(\'002.mp4\', \'wb\') as wf:
for line in rf:
wf.write(line)
十，游标操作
# 1.游标操作的是字节，所有只能在b模式下进行操作
# 2.游标操作可以改变操作位置，r模式下可以改变位置进行操作，所有主模式选择r模式
# 3.seek(offset, whence):
# -- offset为整数就是往后偏移多少个字节，负数就是往前偏移多少个字节
# -- whence：0代表将游标置为开头，1代表从当前位置，2代表将游标置为末尾
# 你是日本人
with open(\'target.txt\', \'rb\') as f:
# 先读6个字节
data = f.read(6)
print(data.decode(\'utf-8\')) # 你是
# 将游标从头开始往后偏移3个字节
f.seek(3, 0)
data = f.read(6)
print(data.decode(\'utf-8\')) # 是日
# 从当前游标位置往前偏移3个字节
f.seek(-3, 1)
data = f.read(3)
print(data.decode(\'utf-8\')) # 日
f.seek(-3, 2)
data = f.read(3)
print(data.decode(\'utf-8\')) # 人
十一，游标案例
\'\'\'
#秒传案例
id_str = b\'\'
with open(\'001.mp4\', \'rb\') as f:
data = f.read()
length = len(data)
print(length)
f.seek(0, 0)
id_str += f.read(10) #读10个字节
f.seek(length // 2, 0)
id_str += f.read(10)
f.seek(-10, 2) #从当前游标位置往前偏移10个字节
id_str += f.read(10)
print(id_str)
new_id_str = b\'\'
with open(\'002.mp4\', \'rb\') as f:
data = f.read()
length = len(data)
print(length)
f.seek(0, 0)
new_id_str += f.read(10)
f.seek(length // 2, 0)
new_id_str += f.read(10)
f.seek(-10, 2)
new_id_str += f.read(10)
if new_id_str == id_str:
print(\'秒传成功\')
else:
print(\'慢传\')
\'\'\'