应用程序运行过程中产生的数据最先都是存放于内存中的，若想永久保存下来，必须要保存于硬盘中。应用程序若想操作硬件必须通过操作系统，而文件就是操作系统提供给应用程序来操作硬盘的虚拟概念，用户或应用程序对文件的操作，就是向操作系统发起调用，然后由操作系统完成对硬盘的具体操作。
有了文件的概念，我们无需再去考虑操作硬盘的细节，只需要关注操作文件的流程：
# 1、打开文件，由应用程序向操作系统发起系统调用open(…)，操作系统打开该文件，对应一块硬盘空间，并返回一个文件对象赋值给一个变量f
f = open('udata.json', encoding='UTF-8') # 默认打开模式是rt
# 2、调用文件对象下的读/写方法，会被操作系统转换为读/写硬盘的操作
data = f.read()
# 3、向操作系统发起关闭文件的请求，回收系统资源
f.close()
打开一个文件包含两部分资源：应用程序的变量 *f* 和操作系统打开的文件。在操作完毕一个文件的时候，必须把与该文件的这两部分资源全部回收，回收方法为：
f.close() # 回收操作系统打开的文件资源
del f # 回收应用程序的变量
其中del f一定要发生在f.close()之后，否则就会导致操作系统打开的文件无法关闭，白白占用资源，而Python的垃圾回收机制决定了我们无需考虑del f，这就要求我们在操作完毕文件后，一定要记住f.close()，虽然我们如此的强调要关闭文件，但是还是会忘记。。。。。。
因此，考虑到这一点，Python提供了with关键字来帮助我们管理上下文。
# 1、在执行完子代码块之后，with会自动执行f.close()
with open('udata.json', 'w') as f:
# 2、可以用with同时打开多个文件，使用逗号分隔开即可
with open('udata.json', 'r') as src_f, open('a.txt', 'w') as dst_f:
data = src_f.read()
dst_f.write(data)
f = open*(...)* # 是由操作系统打开文件，如果打开的是文本文件，会涉及到字符编码的问题，如果没有为open(...)指定编码，那么打开文本文件的默认编码很明显是操作系统说了算的，操作系统会用自己的默认编码去打开文件，在Windows中是GBK，在macOS中是UTF-8。这就涉及到了字符编码的知识：如果要保证不乱码，文件以什么方式存储的，就要以什么方式打开
f = open('a.txt', encoding='UTF-8')
• r（默认）：只读模式
• w：只写模式
• a：只追加写
with open('./text.txt', encoding='UTF-8') as f:
data = f.read() # 会将文件的内容由硬盘全部读入内存，赋值给data
print(data)
# 结果，输出文件里面的内容
haskfljfjfjf
# w只写模式: 在文件不存在时会创建空文档,文件存在会清空文件,文件指针跑到文件开头
with open('./b.txt', 'w') as f:
f.write('你好\n')
f.write('我好\n')
f.write('大家好\n')
f.write('111\n222\n333\n')
# 结果，打开文件能看到输入的内容
强调：
1、在文件不关闭的情况下,连续的写入，后写的内容一定跟在前写内容的后面
2、如果重新以w模式打开文件，则会清空文件内容
# a只追加写模式: 在文件不存在时会创建空文档,文件存在会将文件指针直接移动到文件末尾
with open('./c.txt', 'a') as f:
f.write('44444\n')
f.write('55555\n')
强调 w 模式与 a 模式的异同：
相同点：在打开的文件不关闭的情况下，连续的写入，新写的内容总会跟在前写的内容之后
不同点：以 a 模式重新打开文件，不会清空原文件内容，会将文件指针直接移动到文件末尾，新写的内容永远写在最后
# r+ w+ a+ :可读可写
# 在平时工作中，我们只单纯使用r/w/a，要么只读，要么只写，一般不用可读可写的模式
前提: tb模式均不能单独使用,必须与r/w/a之一结合使用
1. 读写文件都是以字符串为单位的
2. 只能针对文本文件
3. 如果是Windows系统，那么必须指定encoding参数为UTF*-8，因为Windows系统默认的编码为GBK，不指定可能会导致乱码。*
强调：t模式只能用于操作文本文件,无论读写，都应该以字符串为单位，而存取硬盘本质都是二进制的形式，当指定t模式时，内部帮我们做了编码与解码
# t 模式：如果我们指定的文件打开模式为r/w/a，其实默认就是rt/wt/at
with open('a.txt', 'wt') as f:
s = 'abc'
f.write(s) # 写入的也必须是字符串类型
with open('c.txt', 'rt', encoding='UTF-8') as f:
res = f.read()
print(type(res)) # 输出结果为：<class 'str'>
1.读写文件都是以bytes二进制为单位的
2. 可以针对所有文件
3. 一定不能指定encoding参数
# b: 读写都是以二进制位单位
with open('a.txt', 'wb') as f:
msg = "你好"
res = msg.encode('UTF-8') # res为bytes类型
f.write(res) # 在b模式下写入文件的只能是bytes类型
with open('a.txt', 'rb') as f:
data = f.read()
print(type(data)) # 输出结果为：<class 'bytes'>
1、在操作纯文本文件方面t模式帮我们省去了编码与解码的环节，b模式则需要手动编码与解码，所以此时t模式更为方便
2、针对非文本文件（如图片、视频、音频等）只能使用b模式
3、在b模式不能用encoding来指定编码
src_file = input('源文件路径: ').strip()
dst_file = input('目标文件路径: ').strip()
with open(f'{src_file}', 'rb') as src_f, open(f'{dst_file}', 'wb') as dst_f:
for line in src_f:
dst_f.write(line)
f.read() # 读取所有内容,执行完该操作后，文件指针会移动到文件末尾
f.readline() # 读取一行内容,光标移动到第二行首部
f.readlines() # 读取每一行内容,存放于列表中
f.read()与f.readlines()都是将内容一次性读入内容，如果内容过大会导致内存溢出，若还想将内容全读入内存，则必须分多次读入，有两种实现方式：
with open('a.txt', 'rt', encoding='UTF-8') as f:
for line in f:
print(line) # 同一时刻只读入一行内容到内存中
with open('1.mp4', 'rb') as f:
while True:
data = f.read(1024) # 同一时刻只读入1024个Bytes到内存中
if len(data) == 0:
break
print(data)
f.write('1111\n222\n*'**)* # 针对文本模式的写，需要自己写换行符，注意：不同操作系统的换行符是不同的，Windows系统的换行符是：\r\n，而类unix系统的换行符是\n
f.write('1111\n222\n*'.encode('UTF-8'**))* # 针对b模式的写，需要自己写换行符
f.writelines(['333\n**','444**\n**'**]) # 针对文本模式的写，需要自己写换行符
f.writelines([bytes('333\n**', encoding='UTF-8'),'444\n**'.encode('UTF-8'**)]) # 针对b模式的写，需要自己写换行符
f.readable() # 文件是否可读
f.writable() # 文件是否可写
f.closed # 文件是否关闭
f.encoding # 文件的编码，如果文件打开模式为b,则没有该属性
f.flush() # 立刻将文件内容从内存刷到硬盘
f.name # 文件的名字
大前提：文件内指针的移动都是Bytes为单位的，只有在t模式下的f.read(n)，此时 n 的单位是：字符，也就是多少字符的含义。
with open('c.txt', 'rt') as f:
data = f.read(3) # 读取3个字符
print(data)
with open('c.txt', 'rb') as f:
data = f.read(3) # 读取3个Bytes
print(data)
# 结果
你好
b'\xc4\xe3\xba'
\之前文件内指针的移动都是由读/写操作而被动触发的，若想读取文件某一特定位置的数据，则需要用f.seek方法控制文件内指针的移动，
强调：其中 0 模式可以在 t 或者 b 模式使用，而 1 跟 2 模式只能在 b 模式下用,详细用法如下：
f.seek(指针移动的字节数, 模式控制):
模式控制:
0: 默认的模式,该模式代表指针移动的字节数是以文件开头为参照的
1: 该模式代表指针移动的字节数是以当前所在的位置为参照的
2: 该模式代表指针移动的字节数是以文件末尾的位置为参照的
# a.txt用utf-8编码，内容如下（abc各占1个字节，中文“你好”各占3个字节）
abc你好
# 写入文件
with open('c.txt', 'wt', encoding='UTF-8') as f:
s = 'abc你好'
f.write(s)
# 查看写入是否正确
with open('c.txt', 'rt', encoding='UTF-8') as f:
data = f.read()
print('文件内容：', data)
# 0模式
with open('c.txt', 'rt', encoding='UTF-8') as f:
f.seek(3, 0) # 参照文件开头移动了3个字节
print(f.tell()) # 查看当前文件指针距离文件开头的位置，输出结果为3
print(f.read()) # 从第3个字节的位置读到文件末尾，输出结果为：你好
# 注意：由于在t模式下，会将读取的内容自动解码，所以必须保证读取的内容是一个完整中文数据，否则解码失败
with open ('c.txt', 'rt', encoding='UTF-8') as f:
f.seek(6, 0)
data = f.read()
print(data)
# 1模式
with open ('c.txt', 'rb') as f:
f.seek(3, 1) # 从当前位置往后移动3个字节，而此时的当前位置就是文件开头
print(f.tell()) # 输出结果为：3
f.seek(4, 1) # 从当前位置往后移动4个字节，而此时的当前位置为3
print(f.tell()) # 输出结果为：7
# 2模式
with open('c.txt', 'rb') as f:
f.seek(0, 2) # 参照文件末尾移动0个字节，即直接跳到文件末尾
print(f.tell()) # 输出结果为：9
f.seek(-3, 2) # 参照文件末尾往前移动了3个字节
print(f.read().decode('UTF-8')) # 输出结果为：好
# 结果
文件内容： abc你好
3
你好
好
3
7
9
好
import time
with open('access.log', 'rb') as f:
f.seek(0, 2)
while True:
line = f.readline()
if len(line) == 0:
# 没有内容
time.sleep(0.5)
else:
print(line.decode('UTF-8'), end='')
# 文件a.txt的内容如下
TimCook USA 185 65 12312312321
Json USA 163 60 14324324234
Tom USA 175 62 1231243423421
with open('a.txt', 'wt', encoding='UTF-8') as f:
data = "TimCook USA 185 65 12312312321\nJson USA 163 60 14324324234\nTom USA 175 62 1231243423421"
f.write(data)
with open('a.txt', 'rt', encoding='UTF-8') as f:
res = f.read()
print('修改之前: \n', res)
with open('a.txt', 'r+t', encoding='UTF-8') as f:
f.seek(7)
f.write('<Apple>')
with open('a.txt', 'rt', encoding='UTF-8') as f:
res = f.read()
print('修改之后：\n', res)
# 结果
修改之前:
TimCook USA 185 65 12312312321
Json USA 163 60 14324324234
Tom USA 175 62 1231243423421
修改之后：
TimCook<Apple>5 65 12312312321
Json USA 163 60 14324324234
Tom USA 175 62 1231243423421
强调：
1、硬盘空间是无法修改的，硬盘中数据的更新都是用新内容覆盖旧内容
2、内存中的数据是可以修改的
文件对应的是硬盘空间，硬盘不能修改对应着文件本质上也不能修改，那么我们看到文件的内容可以修改，是如何实现的呢？
大致的思路是将硬盘中的文件内容读取到内存中，然后在内存中修改完毕后再覆盖回硬盘，具体的实现方式分为两种。
实现思路：将文件内容一次性全部读入内存，然后在内存中修改完毕之后再覆盖写回源文件
优点：在文件修改过程中同一份数据只有一份
缺点：会过多的占用内存
with open('a.txt', 'wt', encoding='UTF-8') as f:
data = "TimCook USA 185 65 12312312321\nJson USA 163 60 14324324234\nTom USA 175 62 1231243423421"
f.write(data)
with open('a.txt', 'rt', encoding='UTF-8') as f:
res = f.read()
print('修改之前: \n', res)
with open('a.txt', 'w', encoding='UTF-8') as f:
f.write(res.replace('USA', 'CHINA'))
with open('a.txt', 'rt', encoding='UTF-8') as f:
res = f.read()
print('修改之后：\n', res)
# 结果
修改之前:
TimCook USA 185 65 12312312321
Json USA 163 60 14324324234
Tom USA 175 62 1231243423421
修改之后：
TimCook CHINA 185 65 12312312321
Json CHINA 163 60 14324324234
Tom CHINA 175 62 1231243423421
实现思路：以读的方式打开源文件，以写的方式打开一个临时文件，一行行读取源文件内容，修改完之后写入临时文件，删除源文件，将临时文件重命名为源文件名
优点：不会占用过多的内存
缺点：在文件修改过程中同一份数据保存了两份
import os
with open('a.txt', 'wt', encoding='UTF-8') as f:
data = "TimCook USA 185 65 12312312321\nJson USA 163 60 14324324234\nTom USA 175 62 1231243423421"
f.write(data)
with open('a.txt', 'rt', encoding='UTF-8') as f:
res = f.read()
print('修改之前: \n', res)
with open('a.txt', 'r') as src_f, open('.a.txt.swap', 'w') as dst_f:
for line in src_f:
dst_f.write(line.replace('USA', 'China'))
os.remove('a.txt')
os.rename('.a.txt.swap', 'a.txt')
with open('a.txt', 'rt', encoding='UTF-8') as f:
res = f.read()
print('修改之后：\n', res)
jiao@666
